@futdevpro/nts-dynamo 1.15.144 → 1.15.145

package/src/_modules/ai/_modules/document-ai/_collections/dai-code-chunking.util.spec.ts

@@ -1,295 +1,295 @@
-import { DyNTS_DAI_CodeChunking_Util } from './dai-code-chunking.util';
-import { DyNTS_DAI_CodeChunk } from '../_models/interfaces/dai-code-chunk.interface';
-
-/**
- * `DyNTS_DAI_CodeChunking_Util` spec-jei (BFR-AM-005) — AST-szemantikus kód-chunking.
- * Tiszta (NEM Mongo / NEM network): minden teszt csak forrás-string-et chunkol.
- */
-describe('| DyNTS_DAI_CodeChunking_Util', () => {
-
-  describe('| chunkTs — empty / tiny input', () => {
-    it('| should return empty list for empty content', () => {
-      expect(DyNTS_DAI_CodeChunking_Util.chunkTs('')).toEqual([]);
-    });
-
-    it('| should return empty list for whitespace-only content', () => {
-      expect(DyNTS_DAI_CodeChunking_Util.chunkTs('   \n  \t \n ')).toEqual([]);
-    });
-
-    it('| should fall back to a single fallback chunk for tiny non-parseable content', () => {
-      const chunks: DyNTS_DAI_CodeChunk[] = DyNTS_DAI_CodeChunking_Util.chunkTs('x');
-      expect(chunks.length).toBe(1);
-      expect(chunks[0].chunkType).toBe('fallback');
-      expect(chunks[0].content).toBe('x');
-    });
-  });
-
-  describe('| chunkTs — import-group', () => {
-    it('| should group consecutive imports into a single chunk', () => {
-      const code: string = [
-        `import { A } from './a';`,
-        `import { B } from './b';`,
-        `import * as c from './c';`,
-        ``,
-        `export const value: number = 1;`,
-      ].join('\n');
-
-      const chunks: DyNTS_DAI_CodeChunk[] = DyNTS_DAI_CodeChunking_Util.chunkTs(code);
-      const importChunks: DyNTS_DAI_CodeChunk[] = chunks.filter((c: DyNTS_DAI_CodeChunk) => c.chunkType === 'imports');
-
-      expect(importChunks.length).toBe(1);
-      expect(importChunks[0].content).toContain(`from './a'`);
-      expect(importChunks[0].content).toContain(`from './b'`);
-      expect(importChunks[0].content).toContain(`from './c'`);
-      expect(importChunks[0].symbolPath).toBe('');
-    });
-
-    it('| should treat re-export (export ... from) as part of the import group', () => {
-      const code: string = [
-        `import { A } from './a';`,
-        `export { B } from './b';`,
-        ``,
-        `function helper(): void {}`,
-      ].join('\n');
-
-      const chunks: DyNTS_DAI_CodeChunk[] = DyNTS_DAI_CodeChunking_Util.chunkTs(code);
-      const importChunks: DyNTS_DAI_CodeChunk[] = chunks.filter((c: DyNTS_DAI_CodeChunk) => c.chunkType === 'imports');
-
-      expect(importChunks.length).toBe(1);
-      expect(importChunks[0].content).toContain(`export { B } from './b'`);
-    });
-  });
-
-  describe('| chunkTs — top-level declarations', () => {
-    it('| should chunk an interface', () => {
-      const code: string = `export interface FooParams {\n  a: string;\n  b: number;\n}`;
-      const chunks: DyNTS_DAI_CodeChunk[] = DyNTS_DAI_CodeChunking_Util.chunkTs(code);
-
-      const iface: DyNTS_DAI_CodeChunk | undefined = chunks.find((c: DyNTS_DAI_CodeChunk) => c.chunkType === 'interface');
-      expect(iface).toBeDefined();
-      expect(iface!.symbolName).toBe('FooParams');
-      expect(iface!.symbolPath).toBe('interface:FooParams');
-    });
-
-    it('| should chunk an enum', () => {
-      const code: string = `export enum Color {\n  red = 'red',\n  green = 'green',\n}`;
-      const chunks: DyNTS_DAI_CodeChunk[] = DyNTS_DAI_CodeChunking_Util.chunkTs(code);
-
-      const en: DyNTS_DAI_CodeChunk | undefined = chunks.find((c: DyNTS_DAI_CodeChunk) => c.chunkType === 'enum');
-      expect(en).toBeDefined();
-      expect(en!.symbolPath).toBe('enum:Color');
-    });
-
-    it('| should chunk a type-alias', () => {
-      const code: string = `export type Id = string | number;`;
-      const chunks: DyNTS_DAI_CodeChunk[] = DyNTS_DAI_CodeChunking_Util.chunkTs(code);
-
-      const typeChunk: DyNTS_DAI_CodeChunk | undefined = chunks.find((c: DyNTS_DAI_CodeChunk) => c.chunkType === 'type');
-      expect(typeChunk).toBeDefined();
-      expect(typeChunk!.symbolPath).toBe('type:Id');
-    });
-
-    it('| should chunk a standalone function', () => {
-      const code: string = `export function doThing(x: number): number {\n  return x + 1;\n}`;
-      const chunks: DyNTS_DAI_CodeChunk[] = DyNTS_DAI_CodeChunking_Util.chunkTs(code);
-
-      const fn: DyNTS_DAI_CodeChunk | undefined = chunks.find((c: DyNTS_DAI_CodeChunk) => c.chunkType === 'function');
-      expect(fn).toBeDefined();
-      expect(fn!.symbolPath).toBe('function:doThing');
-    });
-
-    it('| should classify an arrow-const as a function chunk', () => {
-      const code: string = `export const adder = (a: number, b: number): number => {\n  return a + b;\n};`;
-      const chunks: DyNTS_DAI_CodeChunk[] = DyNTS_DAI_CodeChunking_Util.chunkTs(code);
-
-      const fn: DyNTS_DAI_CodeChunk | undefined = chunks.find((c: DyNTS_DAI_CodeChunk) => c.symbolName === 'adder');
-      expect(fn).toBeDefined();
-      expect(fn!.chunkType).toBe('function');
-      expect(fn!.symbolPath).toBe('function:adder');
-    });
-  });
-
-  describe('| chunkTs — class (whole vs method-split)', () => {
-    it('| should keep a small class as a single chunk', () => {
-      const code: string = [
-        `export class Small {`,
-        `  greet(): string { return 'hi'; }`,
-        `}`,
-      ].join('\n');
-
-      const chunks: DyNTS_DAI_CodeChunk[] = DyNTS_DAI_CodeChunking_Util.chunkTs(code);
-      const classChunks: DyNTS_DAI_CodeChunk[] = chunks.filter((c: DyNTS_DAI_CodeChunk) => c.chunkType === 'class');
-
-      // Egyetlen, egész-osztály chunk (nincs metódus-bontás kis méretnél).
-      expect(classChunks.length).toBe(1);
-      expect(classChunks[0].symbolPath).toBe('class:Small');
-      expect(classChunks[0].content).toContain('greet');
-    });
-
-    it('| should split a large class by methods with class:Foo > method:bar symbolPaths', () => {
-      // Minden metódus body-ja kellően nagy, hogy az osztály a maxChunkSize fölé nőjön.
-      const body: string = `    const v = ${'1 + '.repeat(60)}1;\n    return v;`;
-      const code: string = [
-        `export class BigService {`,
-        `  alpha(): number {\n${body}\n  }`,
-        `  beta(): number {\n${body}\n  }`,
-        `  gamma(): number {\n${body}\n  }`,
-        `}`,
-      ].join('\n');
-
-      // maxChunkSize=400: minden metódus (~292) belefér egy chunkba, de az egész osztály (~911)
-      // NEM → pontosan osztály-fej + 3 metódus-chunk.
-      const chunks: DyNTS_DAI_CodeChunk[] = DyNTS_DAI_CodeChunking_Util.chunkTs(code, { maxChunkSize: 400 });
-
-      const methodChunks: DyNTS_DAI_CodeChunk[] = chunks.filter((c: DyNTS_DAI_CodeChunk) => c.chunkType === 'method');
-      const methodPaths: string[] = methodChunks.map((c: DyNTS_DAI_CodeChunk) => c.symbolPath);
-
-      expect(methodChunks.length).toBe(3);
-      expect(methodPaths).toContain('class:BigService > method:alpha');
-      expect(methodPaths).toContain('class:BigService > method:beta');
-      expect(methodPaths).toContain('class:BigService > method:gamma');
-
-      // Az osztály-fej külön chunk, class:BigService symbol-lánccal.
-      const classHeader: DyNTS_DAI_CodeChunk | undefined = chunks.find(
-        (c: DyNTS_DAI_CodeChunk) => c.chunkType === 'class' && c.symbolPath === 'class:BigService'
-      );
-      expect(classHeader).toBeDefined();
-    });
-  });
-
-  describe('| chunkTs — JSDoc + decorator bundling', () => {
-    it('| should bundle a leading JSDoc with the following node', () => {
-      const code: string = [
-        `/**`,
-        ` * Helper function docs.`,
-        ` */`,
-        `export function withDocs(): void {}`,
-      ].join('\n');
-
-      const chunks: DyNTS_DAI_CodeChunk[] = DyNTS_DAI_CodeChunking_Util.chunkTs(code);
-      const fn: DyNTS_DAI_CodeChunk | undefined = chunks.find((c: DyNTS_DAI_CodeChunk) => c.symbolName === 'withDocs');
-
-      expect(fn).toBeDefined();
-      expect(fn!.content).toContain('Helper function docs.');
-      expect(fn!.content).toContain('export function withDocs');
-    });
-
-    it('| should bundle decorators with the following class node', () => {
-      const code: string = [
-        `@Injectable()`,
-        `@Logged`,
-        `export class Decorated {`,
-        `  run(): void {}`,
-        `}`,
-      ].join('\n');
-
-      const chunks: DyNTS_DAI_CodeChunk[] = DyNTS_DAI_CodeChunking_Util.chunkTs(code);
-      const cls: DyNTS_DAI_CodeChunk | undefined = chunks.find((c: DyNTS_DAI_CodeChunk) => c.symbolName === 'Decorated');
-
-      expect(cls).toBeDefined();
-      expect(cls!.content).toContain('@Injectable()');
-      expect(cls!.content).toContain('@Logged');
-    });
-  });
-
-  describe('| chunkTs — large-node sliding-split', () => {
-    it('| should sliding-split a single oversized function into sub-chunks', () => {
-      const longBody: string = Array.from({ length: 80 }, (_: unknown, i: number) => `  const x${i} = ${i};`).join('\n');
-      const code: string = `export function huge(): void {\n${longBody}\n}`;
-
-      const chunks: DyNTS_DAI_CodeChunk[] = DyNTS_DAI_CodeChunking_Util.chunkTs(code, { maxChunkSize: 300, overlap: 50 });
-
-      // Több sub-chunk, mind ugyanazzal a symbol-lánccal + subChunkIndex-szel.
-      expect(chunks.length).toBeGreaterThan(1);
-      chunks.forEach((c: DyNTS_DAI_CodeChunk) => {
-        expect(c.symbolPath).toBe('function:huge');
-        expect(c.subChunkIndex).toBeGreaterThanOrEqual(0);
-        expect(c.content.length).toBeLessThanOrEqual(300);
-      });
-      // A sub-chunk-indexek 0-tól folytonosak.
-      expect(chunks[0].subChunkIndex).toBe(0);
-    });
-  });
-
-  describe('| chunkTs — positions', () => {
-    it('| should report 1-based source line numbers', () => {
-      const code: string = [
-        `import { A } from './a';`, // line 1
-        ``,                          // line 2
-        `export function f(): void {`, // line 3
-        `  return;`,                  // line 4
-        `}`,                          // line 5
-      ].join('\n');
-
-      const chunks: DyNTS_DAI_CodeChunk[] = DyNTS_DAI_CodeChunking_Util.chunkTs(code);
-      const fn: DyNTS_DAI_CodeChunk | undefined = chunks.find((c: DyNTS_DAI_CodeChunk) => c.symbolName === 'f');
-
-      expect(fn).toBeDefined();
-      expect(fn!.lineStart).toBe(3);
-      expect(fn!.lineEnd).toBe(5);
-    });
-
-    it('| should assign contiguous 0-based chunkIndex values', () => {
-      const code: string = [
-        `import { A } from './a';`,
-        `export interface I { x: number; }`,
-        `export type T = string;`,
-        `export function fn(): void {}`,
-      ].join('\n');
-
-      const chunks: DyNTS_DAI_CodeChunk[] = DyNTS_DAI_CodeChunking_Util.chunkTs(code);
-      chunks.forEach((c: DyNTS_DAI_CodeChunk, i: number) => {
-        expect(c.chunkIndex).toBe(i);
-      });
-    });
-  });
-
-  describe('| chunk — dispatcher routing', () => {
-    it('| should route .ts files through the AST chunker', () => {
-      const code: string = `export class Routed {\n  go(): void {}\n}`;
-      const chunks: DyNTS_DAI_CodeChunk[] = DyNTS_DAI_CodeChunking_Util.chunk(code, 'foo.ts');
-
-      expect(chunks.some((c: DyNTS_DAI_CodeChunk) => c.symbolPath === 'class:Routed')).toBe(true);
-    });
-
-    it('| should route .tsx/.js/.jsx files through the AST chunker', () => {
-      const code: string = `export function widget(): void {}`;
-      expect(DyNTS_DAI_CodeChunking_Util.chunk(code, 'a.tsx').some((c: DyNTS_DAI_CodeChunk) => c.symbolName === 'widget')).toBe(true);
-      expect(DyNTS_DAI_CodeChunking_Util.chunk(code, 'b.js').some((c: DyNTS_DAI_CodeChunk) => c.symbolName === 'widget')).toBe(true);
-      expect(DyNTS_DAI_CodeChunking_Util.chunk(code, 'c.jsx').some((c: DyNTS_DAI_CodeChunk) => c.symbolName === 'widget')).toBe(true);
-    });
-
-    it('| should route non-code (.md) content to fallback chunks (no semantic split)', () => {
-      const content: string = `# Title\n\nSome markdown text.`;
-      const chunks: DyNTS_DAI_CodeChunk[] = DyNTS_DAI_CodeChunking_Util.chunk(content, 'readme.md');
-
-      expect(chunks.length).toBe(1);
-      expect(chunks[0].chunkType).toBe('fallback');
-      expect(chunks[0].content).toContain('# Title');
-    });
-
-    it('| should return empty for empty non-code content', () => {
-      expect(DyNTS_DAI_CodeChunking_Util.chunk('', 'readme.md')).toEqual([]);
-    });
-  });
-
-  describe('| chunkTs — robustness (braces inside strings/templates)', () => {
-    it('| should not be confused by braces inside string and template literals (AST-correct)', () => {
-      // A FAM regex/brace-depth workaround itt tévedne; az AST helyesen kezeli.
-      const code: string = [
-        `export function tricky(): string {`,
-        '  const a = "} not a real close {";',
-        '  const b = `template ${ a } with } braces {`;',
-        `  return a + b;`,
-        `}`,
-        `export interface AfterTricky { ok: boolean; }`,
-      ].join('\n');
-
-      const chunks: DyNTS_DAI_CodeChunk[] = DyNTS_DAI_CodeChunking_Util.chunkTs(code);
-
-      // A függvény ÉS az utána jövő interface is külön, helyes chunk (nem olvad össze).
-      expect(chunks.some((c: DyNTS_DAI_CodeChunk) => c.symbolPath === 'function:tricky')).toBe(true);
-      expect(chunks.some((c: DyNTS_DAI_CodeChunk) => c.symbolPath === 'interface:AfterTricky')).toBe(true);
-    });
-  });
-});
+import { DyNTS_DAI_CodeChunking_Util } from './dai-code-chunking.util';
+import { DyNTS_DAI_CodeChunk } from '../_models/interfaces/dai-code-chunk.interface';
+
+/**
+ * `DyNTS_DAI_CodeChunking_Util` spec-jei (BFR-AM-005) — AST-szemantikus kód-chunking.
+ * Tiszta (NEM Mongo / NEM network): minden teszt csak forrás-string-et chunkol.
+ */
+describe('| DyNTS_DAI_CodeChunking_Util', () => {
+
+  describe('| chunkTs — empty / tiny input', () => {
+    it('| should return empty list for empty content', () => {
+      expect(DyNTS_DAI_CodeChunking_Util.chunkTs('')).toEqual([]);
+    });
+
+    it('| should return empty list for whitespace-only content', () => {
+      expect(DyNTS_DAI_CodeChunking_Util.chunkTs('   \n  \t \n ')).toEqual([]);
+    });
+
+    it('| should fall back to a single fallback chunk for tiny non-parseable content', () => {
+      const chunks: DyNTS_DAI_CodeChunk[] = DyNTS_DAI_CodeChunking_Util.chunkTs('x');
+      expect(chunks.length).toBe(1);
+      expect(chunks[0].chunkType).toBe('fallback');
+      expect(chunks[0].content).toBe('x');
+    });
+  });
+
+  describe('| chunkTs — import-group', () => {
+    it('| should group consecutive imports into a single chunk', () => {
+      const code: string = [
+        `import { A } from './a';`,
+        `import { B } from './b';`,
+        `import * as c from './c';`,
+        ``,
+        `export const value: number = 1;`,
+      ].join('\n');
+
+      const chunks: DyNTS_DAI_CodeChunk[] = DyNTS_DAI_CodeChunking_Util.chunkTs(code);
+      const importChunks: DyNTS_DAI_CodeChunk[] = chunks.filter((c: DyNTS_DAI_CodeChunk) => c.chunkType === 'imports');
+
+      expect(importChunks.length).toBe(1);
+      expect(importChunks[0].content).toContain(`from './a'`);
+      expect(importChunks[0].content).toContain(`from './b'`);
+      expect(importChunks[0].content).toContain(`from './c'`);
+      expect(importChunks[0].symbolPath).toBe('');
+    });
+
+    it('| should treat re-export (export ... from) as part of the import group', () => {
+      const code: string = [
+        `import { A } from './a';`,
+        `export { B } from './b';`,
+        ``,
+        `function helper(): void {}`,
+      ].join('\n');
+
+      const chunks: DyNTS_DAI_CodeChunk[] = DyNTS_DAI_CodeChunking_Util.chunkTs(code);
+      const importChunks: DyNTS_DAI_CodeChunk[] = chunks.filter((c: DyNTS_DAI_CodeChunk) => c.chunkType === 'imports');
+
+      expect(importChunks.length).toBe(1);
+      expect(importChunks[0].content).toContain(`export { B } from './b'`);
+    });
+  });
+
+  describe('| chunkTs — top-level declarations', () => {
+    it('| should chunk an interface', () => {
+      const code: string = `export interface FooParams {\n  a: string;\n  b: number;\n}`;
+      const chunks: DyNTS_DAI_CodeChunk[] = DyNTS_DAI_CodeChunking_Util.chunkTs(code);
+
+      const iface: DyNTS_DAI_CodeChunk | undefined = chunks.find((c: DyNTS_DAI_CodeChunk) => c.chunkType === 'interface');
+      expect(iface).toBeDefined();
+      expect(iface!.symbolName).toBe('FooParams');
+      expect(iface!.symbolPath).toBe('interface:FooParams');
+    });
+
+    it('| should chunk an enum', () => {
+      const code: string = `export enum Color {\n  red = 'red',\n  green = 'green',\n}`;
+      const chunks: DyNTS_DAI_CodeChunk[] = DyNTS_DAI_CodeChunking_Util.chunkTs(code);
+
+      const en: DyNTS_DAI_CodeChunk | undefined = chunks.find((c: DyNTS_DAI_CodeChunk) => c.chunkType === 'enum');
+      expect(en).toBeDefined();
+      expect(en!.symbolPath).toBe('enum:Color');
+    });
+
+    it('| should chunk a type-alias', () => {
+      const code: string = `export type Id = string | number;`;
+      const chunks: DyNTS_DAI_CodeChunk[] = DyNTS_DAI_CodeChunking_Util.chunkTs(code);
+
+      const typeChunk: DyNTS_DAI_CodeChunk | undefined = chunks.find((c: DyNTS_DAI_CodeChunk) => c.chunkType === 'type');
+      expect(typeChunk).toBeDefined();
+      expect(typeChunk!.symbolPath).toBe('type:Id');
+    });
+
+    it('| should chunk a standalone function', () => {
+      const code: string = `export function doThing(x: number): number {\n  return x + 1;\n}`;
+      const chunks: DyNTS_DAI_CodeChunk[] = DyNTS_DAI_CodeChunking_Util.chunkTs(code);
+
+      const fn: DyNTS_DAI_CodeChunk | undefined = chunks.find((c: DyNTS_DAI_CodeChunk) => c.chunkType === 'function');
+      expect(fn).toBeDefined();
+      expect(fn!.symbolPath).toBe('function:doThing');
+    });
+
+    it('| should classify an arrow-const as a function chunk', () => {
+      const code: string = `export const adder = (a: number, b: number): number => {\n  return a + b;\n};`;
+      const chunks: DyNTS_DAI_CodeChunk[] = DyNTS_DAI_CodeChunking_Util.chunkTs(code);
+
+      const fn: DyNTS_DAI_CodeChunk | undefined = chunks.find((c: DyNTS_DAI_CodeChunk) => c.symbolName === 'adder');
+      expect(fn).toBeDefined();
+      expect(fn!.chunkType).toBe('function');
+      expect(fn!.symbolPath).toBe('function:adder');
+    });
+  });
+
+  describe('| chunkTs — class (whole vs method-split)', () => {
+    it('| should keep a small class as a single chunk', () => {
+      const code: string = [
+        `export class Small {`,
+        `  greet(): string { return 'hi'; }`,
+        `}`,
+      ].join('\n');
+
+      const chunks: DyNTS_DAI_CodeChunk[] = DyNTS_DAI_CodeChunking_Util.chunkTs(code);
+      const classChunks: DyNTS_DAI_CodeChunk[] = chunks.filter((c: DyNTS_DAI_CodeChunk) => c.chunkType === 'class');
+
+      // Egyetlen, egész-osztály chunk (nincs metódus-bontás kis méretnél).
+      expect(classChunks.length).toBe(1);
+      expect(classChunks[0].symbolPath).toBe('class:Small');
+      expect(classChunks[0].content).toContain('greet');
+    });
+
+    it('| should split a large class by methods with class:Foo > method:bar symbolPaths', () => {
+      // Minden metódus body-ja kellően nagy, hogy az osztály a maxChunkSize fölé nőjön.
+      const body: string = `    const v = ${'1 + '.repeat(60)}1;\n    return v;`;
+      const code: string = [
+        `export class BigService {`,
+        `  alpha(): number {\n${body}\n  }`,
+        `  beta(): number {\n${body}\n  }`,
+        `  gamma(): number {\n${body}\n  }`,
+        `}`,
+      ].join('\n');
+
+      // maxChunkSize=400: minden metódus (~292) belefér egy chunkba, de az egész osztály (~911)
+      // NEM → pontosan osztály-fej + 3 metódus-chunk.
+      const chunks: DyNTS_DAI_CodeChunk[] = DyNTS_DAI_CodeChunking_Util.chunkTs(code, { maxChunkSize: 400 });
+
+      const methodChunks: DyNTS_DAI_CodeChunk[] = chunks.filter((c: DyNTS_DAI_CodeChunk) => c.chunkType === 'method');
+      const methodPaths: string[] = methodChunks.map((c: DyNTS_DAI_CodeChunk) => c.symbolPath);
+
+      expect(methodChunks.length).toBe(3);
+      expect(methodPaths).toContain('class:BigService > method:alpha');
+      expect(methodPaths).toContain('class:BigService > method:beta');
+      expect(methodPaths).toContain('class:BigService > method:gamma');
+
+      // Az osztály-fej külön chunk, class:BigService symbol-lánccal.
+      const classHeader: DyNTS_DAI_CodeChunk | undefined = chunks.find(
+        (c: DyNTS_DAI_CodeChunk) => c.chunkType === 'class' && c.symbolPath === 'class:BigService'
+      );
+      expect(classHeader).toBeDefined();
+    });
+  });
+
+  describe('| chunkTs — JSDoc + decorator bundling', () => {
+    it('| should bundle a leading JSDoc with the following node', () => {
+      const code: string = [
+        `/**`,
+        ` * Helper function docs.`,
+        ` */`,
+        `export function withDocs(): void {}`,
+      ].join('\n');
+
+      const chunks: DyNTS_DAI_CodeChunk[] = DyNTS_DAI_CodeChunking_Util.chunkTs(code);
+      const fn: DyNTS_DAI_CodeChunk | undefined = chunks.find((c: DyNTS_DAI_CodeChunk) => c.symbolName === 'withDocs');
+
+      expect(fn).toBeDefined();
+      expect(fn!.content).toContain('Helper function docs.');
+      expect(fn!.content).toContain('export function withDocs');
+    });
+
+    it('| should bundle decorators with the following class node', () => {
+      const code: string = [
+        `@Injectable()`,
+        `@Logged`,
+        `export class Decorated {`,
+        `  run(): void {}`,
+        `}`,
+      ].join('\n');
+
+      const chunks: DyNTS_DAI_CodeChunk[] = DyNTS_DAI_CodeChunking_Util.chunkTs(code);
+      const cls: DyNTS_DAI_CodeChunk | undefined = chunks.find((c: DyNTS_DAI_CodeChunk) => c.symbolName === 'Decorated');
+
+      expect(cls).toBeDefined();
+      expect(cls!.content).toContain('@Injectable()');
+      expect(cls!.content).toContain('@Logged');
+    });
+  });
+
+  describe('| chunkTs — large-node sliding-split', () => {
+    it('| should sliding-split a single oversized function into sub-chunks', () => {
+      const longBody: string = Array.from({ length: 80 }, (_: unknown, i: number) => `  const x${i} = ${i};`).join('\n');
+      const code: string = `export function huge(): void {\n${longBody}\n}`;
+
+      const chunks: DyNTS_DAI_CodeChunk[] = DyNTS_DAI_CodeChunking_Util.chunkTs(code, { maxChunkSize: 300, overlap: 50 });
+
+      // Több sub-chunk, mind ugyanazzal a symbol-lánccal + subChunkIndex-szel.
+      expect(chunks.length).toBeGreaterThan(1);
+      chunks.forEach((c: DyNTS_DAI_CodeChunk) => {
+        expect(c.symbolPath).toBe('function:huge');
+        expect(c.subChunkIndex).toBeGreaterThanOrEqual(0);
+        expect(c.content.length).toBeLessThanOrEqual(300);
+      });
+      // A sub-chunk-indexek 0-tól folytonosak.
+      expect(chunks[0].subChunkIndex).toBe(0);
+    });
+  });
+
+  describe('| chunkTs — positions', () => {
+    it('| should report 1-based source line numbers', () => {
+      const code: string = [
+        `import { A } from './a';`, // line 1
+        ``,                          // line 2
+        `export function f(): void {`, // line 3
+        `  return;`,                  // line 4
+        `}`,                          // line 5
+      ].join('\n');
+
+      const chunks: DyNTS_DAI_CodeChunk[] = DyNTS_DAI_CodeChunking_Util.chunkTs(code);
+      const fn: DyNTS_DAI_CodeChunk | undefined = chunks.find((c: DyNTS_DAI_CodeChunk) => c.symbolName === 'f');
+
+      expect(fn).toBeDefined();
+      expect(fn!.lineStart).toBe(3);
+      expect(fn!.lineEnd).toBe(5);
+    });
+
+    it('| should assign contiguous 0-based chunkIndex values', () => {
+      const code: string = [
+        `import { A } from './a';`,
+        `export interface I { x: number; }`,
+        `export type T = string;`,
+        `export function fn(): void {}`,
+      ].join('\n');
+
+      const chunks: DyNTS_DAI_CodeChunk[] = DyNTS_DAI_CodeChunking_Util.chunkTs(code);
+      chunks.forEach((c: DyNTS_DAI_CodeChunk, i: number) => {
+        expect(c.chunkIndex).toBe(i);
+      });
+    });
+  });
+
+  describe('| chunk — dispatcher routing', () => {
+    it('| should route .ts files through the AST chunker', () => {
+      const code: string = `export class Routed {\n  go(): void {}\n}`;
+      const chunks: DyNTS_DAI_CodeChunk[] = DyNTS_DAI_CodeChunking_Util.chunk(code, 'foo.ts');
+
+      expect(chunks.some((c: DyNTS_DAI_CodeChunk) => c.symbolPath === 'class:Routed')).toBe(true);
+    });
+
+    it('| should route .tsx/.js/.jsx files through the AST chunker', () => {
+      const code: string = `export function widget(): void {}`;
+      expect(DyNTS_DAI_CodeChunking_Util.chunk(code, 'a.tsx').some((c: DyNTS_DAI_CodeChunk) => c.symbolName === 'widget')).toBe(true);
+      expect(DyNTS_DAI_CodeChunking_Util.chunk(code, 'b.js').some((c: DyNTS_DAI_CodeChunk) => c.symbolName === 'widget')).toBe(true);
+      expect(DyNTS_DAI_CodeChunking_Util.chunk(code, 'c.jsx').some((c: DyNTS_DAI_CodeChunk) => c.symbolName === 'widget')).toBe(true);
+    });
+
+    it('| should route non-code (.md) content to fallback chunks (no semantic split)', () => {
+      const content: string = `# Title\n\nSome markdown text.`;
+      const chunks: DyNTS_DAI_CodeChunk[] = DyNTS_DAI_CodeChunking_Util.chunk(content, 'readme.md');
+
+      expect(chunks.length).toBe(1);
+      expect(chunks[0].chunkType).toBe('fallback');
+      expect(chunks[0].content).toContain('# Title');
+    });
+
+    it('| should return empty for empty non-code content', () => {
+      expect(DyNTS_DAI_CodeChunking_Util.chunk('', 'readme.md')).toEqual([]);
+    });
+  });
+
+  describe('| chunkTs — robustness (braces inside strings/templates)', () => {
+    it('| should not be confused by braces inside string and template literals (AST-correct)', () => {
+      // A FAM regex/brace-depth workaround itt tévedne; az AST helyesen kezeli.
+      const code: string = [
+        `export function tricky(): string {`,
+        '  const a = "} not a real close {";',
+        '  const b = `template ${ a } with } braces {`;',
+        `  return a + b;`,
+        `}`,
+        `export interface AfterTricky { ok: boolean; }`,
+      ].join('\n');
+
+      const chunks: DyNTS_DAI_CodeChunk[] = DyNTS_DAI_CodeChunking_Util.chunkTs(code);
+
+      // A függvény ÉS az utána jövő interface is külön, helyes chunk (nem olvad össze).
+      expect(chunks.some((c: DyNTS_DAI_CodeChunk) => c.symbolPath === 'function:tricky')).toBe(true);
+      expect(chunks.some((c: DyNTS_DAI_CodeChunk) => c.symbolPath === 'interface:AfterTricky')).toBe(true);
+    });
+  });
+});