@futdevpro/nts-dynamo 1.15.156 → 1.15.160

package/build/_modules/ai/_modules/document-ai/_collections/dai-code-chunking.util.js

@@ -1,419 +1,419 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.DyNTS_DAI_CodeChunking_Util = void 0;
-const tslib_1 = require("tslib");
-const ts = tslib_1.__importStar(require("typescript"));
-const fsm_dynamo_1 = require("@futdevpro/fsm-dynamo");
-/**
- * `DyNTS_DAI_CodeChunking_Util` (BFR-AM-005) — **AST-pontos** TypeScript/JavaScript kód-chunker
- * a TypeScript Compiler API-val (`ts.createSourceFile`). A FAM `FAM_TsChunker_Util` regex/brace-depth
- * workaround-jának **bedrock-szintű, durable** változata: a `{`/`}` számolás helyett a valódi
- * szintaxisfát járja be, így string-literálban / template-literálban / comment-ben lévő zárójelek
- * NEM tévesztik meg.
- *
- * **Chunkolási stratégia (top-level node-onként, egy chunk per szemantikus egység):**
- * - **import-group** — az összes egymást követő top-level `import` / `export ... from` egy chunkba
- *   (a köztük lévő üres sorokkal együtt).
- * - **class** — ha belefér a `maxChunkSize`-ba, az egész osztály egy chunk (dekorátorok + JSDoc-cal);
- *   ha NEM fér bele, **metódusonként** bomlik (osztály-fej + minden metódus külön chunk, a
- *   `class:Foo > method:bar` symbol-lánccal).
- * - **interface / enum / type-alias / standalone function / top-level const(=>fn/value)** — egy chunk
- *   per deklaráció.
- * - **nagy node** (a fentiek közül bármelyik, ami a metódus-bontás UTÁN is `maxChunkSize` fölötti) →
- *   karakter-alapú **sliding-window** sub-split (örökölt `chunkType` + symbol-lánc, `subChunkIndex`-szel).
- * - **tiny / parse-degenerált tartalom** → egyetlen `fallback` chunk (a teljes forrás), hogy soha
- *   ne vesszen el tartalom.
- *
- * A JSDoc + `@Decorator` MINDIG a következő node-dal együtt marad (a `node.getStart(sf, true)` a
- * leading-JSDoc elejétől indul, a `ts.getDecorators` a node része).
- *
- * **headingPath = kód-symbol-lánc** (a markdown-chunker heading-láncának kód-megfelelője):
- * `symbolPath` = a szegmensek ` > `-rel összefűzve.
- */
-class DyNTS_DAI_CodeChunking_Util {
-    /** A FAM/CCAP-egyeztetett default méret-konstansok. */
-    static DEFAULT_MAX_CHUNK_SIZE = 1500;
-    static DEFAULT_OVERLAP = 100;
-    static DEFAULT_MIN_CHUNK_SIZE = 50;
-    /**
-     * Egy TS/JS forrás chunkolása szemantikus blokkok mentén a TS Compiler API AST-jával.
-     * Üres / whitespace-only tartalom → üres lista. A `maxChunkSize` fölötti node-ok sliding-window-ra
-     * bomlanak; a degenerált (parse-hiba / 0 blokk) esetet egyetlen `fallback` chunk fedi.
-     *
-     * @param code - A forráskód.
-     * @param opts - Méret-paraméterek (default 1500/100/50).
-     * @returns A szemantikus kód-chunkok listája (0-alapú `chunkIndex`-szel).
-     */
-    static chunkTs(code, opts) {
-        if (!code?.trim()) {
-            return [];
-        }
-        const sizing = this.resolveSizing(opts);
-        let blocks = [];
-        try {
-            const sourceFile = ts.createSourceFile('chunk-input.ts', code, ts.ScriptTarget.Latest, 
-            /* setParentNodes */ true, ts.ScriptKind.TSX);
-            blocks = this.identifyBlocks(sourceFile, code, sizing);
-        }
-        catch (error) {
-            // Parse-hiba (degenerált forrás) → a tiny-fallback veszi át lentebb.
-            fsm_dynamo_1.DyFM_Log.warn('DyNTS_DAI_CodeChunking_Util.chunkTs: AST parse failed, using fallback chunk', {
-                error: error?.message,
-            });
-            blocks = [];
-        }
-        // Tiny / degenerált esetek: ha nincs azonosított blokk, vagy a teljes forrás kicsi → egyetlen
-        // fallback chunk (soha ne vesszen el tartalom).
-        if (!blocks.length) {
-            return this.buildFallbackChunks(code, sizing);
-        }
-        // A sor-pozíciókhoz a teljes forrás sortörés-offszetjei (egyszer számolva).
-        const lineStartOffsets = this.computeLineStartOffsets(code);
-        const chunks = [];
-        for (const block of blocks) {
-            // Zaj-szűrés: CSAK a névtelen `generic` blokkokat dobjuk a minChunkSize alatt. A nevesített
-            // szemantikus deklarációk (type-alias / rövid function / class-fej / metódus / interface /
-            // enum / variable) MINDIG saját chunkot kapnak, méretüktől függetlenül — egy `type Id = string`
-            // teljes értékű egység. Az import-csoport sosem esik ki.
-            if (block.chunkType === 'generic' && block.text.trim().length < sizing.minChunkSize) {
-                continue;
-            }
-            if (block.text.length <= sizing.maxChunkSize) {
-                chunks.push(this.blockToChunk(block, chunks.length, lineStartOffsets));
-                continue;
-            }
-            // Túl nagy node → karakter-alapú sliding-window sub-split (örökölt symbol-lánc + chunkType).
-            this.splitLargeBlock(block, sizing, chunks, lineStartOffsets);
-        }
-        // Ha minden blokk kiesett a minChunkSize-szűrőn (pl. sok apró egysoros), essünk vissza a
-        // fallback-re, hogy ne adjunk vissza üres listát nem-üres bemenetre.
-        if (!chunks.length) {
-            return this.buildFallbackChunks(code, sizing);
-        }
-        return chunks;
-    }
-    /**
-     * Dispatcher: a `filename` kiterjesztése alapján a `.ts/.tsx/.js/.jsx/.mts/.cts/.mjs/.cjs`
-     * forrásokat az AST-chunkerre (`chunkTs`), minden mást (pl. `.md`) az adott formátum nyers
-     * sliding-fallback-jére irányít. A markdown-specifikus chunkolás a `DyNTS_DAI_DocChunking_Util`
-     * felelőssége (page-modell + parent-hierarchia kell hozzá), ezért azt itt NEM hívjuk —
-     * additív marad. Nem-kód input → `fallback` chunk a tartalom megőrzéséhez.
-     *
-     * @param content - A fájl tartalma.
-     * @param filename - A fájlnév (a kiterjesztés-alapú routinghoz).
-     * @param opts - Méret-paraméterek.
-     */
-    static chunk(content, filename, opts) {
-        if (this.isTsLike(filename)) {
-            return this.chunkTs(content, opts);
-        }
-        // Nem-kód (pl. .md / .txt / ismeretlen): nyers fallback chunkok — a tartalmat megőrizzük,
-        // de NEM próbáljuk szemantikusan darabolni (a markdown-darabolás külön util-é).
-        if (!content?.trim()) {
-            return [];
-        }
-        return this.buildFallbackChunks(content, this.resolveSizing(opts));
-    }
-    /** `true`, ha a fájlnév TS/JS-szerű (a `chunkTs` AST-parsere tudja kezelni). */
-    static isTsLike(filename) {
-        return /\.(ts|tsx|mts|cts|js|jsx|mjs|cjs)$/i.test(filename || '');
-    }
-    /** A default-ok feloldása (1500/100/50) + sanity-clamp. */
-    static resolveSizing(opts) {
-        const maxChunkSize = Math.max(1, opts?.maxChunkSize ?? this.DEFAULT_MAX_CHUNK_SIZE);
-        const overlap = Math.max(0, Math.min(opts?.overlap ?? this.DEFAULT_OVERLAP, maxChunkSize - 1));
-        const minChunkSize = Math.max(0, opts?.minChunkSize ?? this.DEFAULT_MIN_CHUNK_SIZE);
-        return { maxChunkSize: maxChunkSize, overlap: overlap, minChunkSize: minChunkSize };
-    }
-    /**
-     * AST-bejárás: a `SourceFile` top-level statement-jeit szemantikus blokkokká alakítja. Az
-     * egymást követő import-okat egy `imports` blokkba vonja össze. A `maxChunkSize` fölötti
-     * osztályt metódusonként bontja.
-     */
-    static identifyBlocks(sourceFile, code, sizing) {
-        const blocks = [];
-        // -- Import-csoport összevonás --
-        let importStart = -1;
-        let importEnd = -1;
-        const flushImports = () => {
-            if (importStart < 0) {
-                return;
-            }
-            const text = code.substring(importStart, importEnd);
-            if (text.trim().length) {
-                blocks.push({
-                    text: text,
-                    chunkType: 'imports',
-                    symbolSegments: [],
-                    symbolName: undefined,
-                    charStart: importStart,
-                    charEnd: importEnd,
-                });
-            }
-            importStart = -1;
-            importEnd = -1;
-        };
-        for (const statement of sourceFile.statements) {
-            if (this.isImportLike(statement)) {
-                const start = statement.getStart(sourceFile, /* includeJsDocComment */ true);
-                if (importStart < 0) {
-                    importStart = start;
-                }
-                importEnd = statement.getEnd();
-                continue;
-            }
-            // Más jött → import-csoport lezárása.
-            flushImports();
-            const detected = this.detectDeclaration(statement);
-            const start = statement.getStart(sourceFile, /* includeJsDocComment */ true);
-            const end = statement.getEnd();
-            const text = code.substring(start, end);
-            const symbolSegments = detected.name ? [`${detected.chunkType}:${detected.name}`] : [];
-            // Nagy osztály → metódusonkénti bontás (osztály-fej + metódusok).
-            if (ts.isClassDeclaration(statement) && text.length > sizing.maxChunkSize) {
-                this.splitClassByMethods(statement, sourceFile, code, detected.name, blocks);
-                continue;
-            }
-            blocks.push({
-                text: text,
-                chunkType: detected.chunkType,
-                symbolSegments: symbolSegments,
-                symbolName: detected.name,
-                charStart: start,
-                charEnd: end,
-            });
-        }
-        // Maradék import-csoport (ha a fájl import-tal végződik).
-        flushImports();
-        return blocks;
-    }
-    /** `true`, ha a statement import / re-export (`export ... from`) — az import-csoporthoz. */
-    static isImportLike(statement) {
-        if (ts.isImportDeclaration(statement) || ts.isImportEqualsDeclaration(statement)) {
-            return true;
-        }
-        // `export { ... } from '...'` / `export * from '...'` — csak ha van moduleSpecifier.
-        if (ts.isExportDeclaration(statement) && !!statement.moduleSpecifier) {
-            return true;
-        }
-        return false;
-    }
-    /** Egy top-level statement → szemantikus chunk-típus + symbol-név. */
-    static detectDeclaration(statement) {
-        if (ts.isClassDeclaration(statement)) {
-            return { chunkType: 'class', name: statement.name?.getText() };
-        }
-        if (ts.isInterfaceDeclaration(statement)) {
-            return { chunkType: 'interface', name: statement.name.getText() };
-        }
-        if (ts.isEnumDeclaration(statement)) {
-            return { chunkType: 'enum', name: statement.name.getText() };
-        }
-        if (ts.isTypeAliasDeclaration(statement)) {
-            return { chunkType: 'type', name: statement.name.getText() };
-        }
-        if (ts.isFunctionDeclaration(statement)) {
-            return { chunkType: 'function', name: statement.name?.getText() };
-        }
-        if (ts.isVariableStatement(statement)) {
-            const firstDecl = statement.declarationList.declarations[0];
-            const name = firstDecl && ts.isIdentifier(firstDecl.name)
-                ? firstDecl.name.getText()
-                : undefined;
-            // Ha a const egy függvény/arrow → 'function', egyébként 'variable'.
-            const initializer = firstDecl?.initializer;
-            const isFn = !!initializer
-                && (ts.isArrowFunction(initializer) || ts.isFunctionExpression(initializer));
-            return { chunkType: isFn ? 'function' : 'variable', name: name };
-        }
-        return { chunkType: 'generic', name: undefined };
-    }
-    /**
-     * Nagy osztály metódusonkénti bontása. Az első chunk az osztály-fej (a class-kulcsszótól az első
-     * tag előttig, dekorátorok + JSDoc-cal), majd minden metódus / property-deklaráció külön chunk a
-     * `class:Foo > method:bar` symbol-lánccal.
-     */
-    static splitClassByMethods(classDecl, sourceFile, code, className, blocks) {
-        const classSegment = `class:${className ?? 'anonymous'}`;
-        const classStart = classDecl.getStart(sourceFile, /* includeJsDocComment */ true);
-        const members = [...classDecl.members];
-        // Osztály-fej: a class kezdetétől az első tag kezdetéig (dekorátorok/JSDoc + `class X {`-rész).
-        const headerEnd = members.length
-            ? members[0].getStart(sourceFile, /* includeJsDocComment */ true)
-            : classDecl.getEnd();
-        const headerText = code.substring(classStart, headerEnd);
-        if (headerText.trim().length) {
-            blocks.push({
-                text: headerText,
-                chunkType: 'class',
-                symbolSegments: [classSegment],
-                symbolName: className,
-                charStart: classStart,
-                charEnd: headerEnd,
-            });
-        }
-        // Tagonkénti chunk (metódus / accessor / property).
-        for (const member of members) {
-            const memberStart = member.getStart(sourceFile, /* includeJsDocComment */ true);
-            const memberEnd = member.getEnd();
-            const memberText = code.substring(memberStart, memberEnd);
-            if (!memberText.trim().length) {
-                continue;
-            }
-            const memberName = member.name && ts.isIdentifier(member.name)
-                ? member.name.getText()
-                : (member.name ? member.name.getText() : undefined);
-            const memberKind = this.classMemberKind(member);
-            const memberSegment = memberName
-                ? `${memberKind}:${memberName}`
-                : memberKind;
-            blocks.push({
-                text: memberText,
-                chunkType: memberKind,
-                symbolSegments: [classSegment, memberSegment],
-                symbolName: memberName,
-                charStart: memberStart,
-                charEnd: memberEnd,
-            });
-        }
-    }
-    /** Egy osztály-tag → chunk-típus (metódus/accessor → 'method', mező → 'variable'). */
-    static classMemberKind(member) {
-        if (ts.isMethodDeclaration(member)
-            || ts.isConstructorDeclaration(member)
-            || ts.isGetAccessorDeclaration(member)
-            || ts.isSetAccessorDeclaration(member)) {
-            return 'method';
-        }
-        return 'variable';
-    }
-    /** Egy belső blokk → `DyNTS_DAI_CodeChunk` (pozíció + symbol-lánc kiszámolásával). */
-    static blockToChunk(block, chunkIndex, lineStartOffsets) {
-        const lineStart = this.lineOfOffset(block.charStart, lineStartOffsets);
-        const lineEnd = this.lineOfOffset(Math.max(block.charStart, block.charEnd - 1), lineStartOffsets);
-        return {
-            content: block.text,
-            chunkType: block.chunkType,
-            symbolPath: block.symbolSegments.join(' > '),
-            symbolSegments: block.symbolSegments,
-            symbolName: block.symbolName,
-            lineStart: lineStart,
-            lineEnd: lineEnd,
-            charStart: block.charStart,
-            charEnd: block.charEnd,
-            chunkIndex: chunkIndex,
-        };
-    }
-    /**
-     * Túl nagy blokk karakter-alapú sliding-window sub-splitje (örökölt chunkType + symbol-lánc).
-     * Az átfedés (`overlap`) karakter-szinten, a `minChunkSize` alatti farok-chunkokat kihagyja.
-     */
-    static splitLargeBlock(block, sizing, out, lineStartOffsets) {
-        const text = block.text;
-        const step = Math.max(1, sizing.maxChunkSize - sizing.overlap);
-        let subChunkIndex = 0;
-        for (let start = 0; start < text.length; start += step) {
-            const end = Math.min(start + sizing.maxChunkSize, text.length);
-            const slice = text.substring(start, end);
-            // A nagyon kicsi farok-chunkot (az utolsó, ami már nem éri el a minChunkSize-t) kihagyjuk,
-            // de csak ha NEM ez az egyetlen chunk.
-            if (slice.trim().length < sizing.minChunkSize && subChunkIndex > 0) {
-                break;
-            }
-            const absoluteCharStart = block.charStart + start;
-            const absoluteCharEnd = block.charStart + end;
-            const lineStart = this.lineOfOffset(absoluteCharStart, lineStartOffsets);
-            const lineEnd = this.lineOfOffset(Math.max(absoluteCharStart, absoluteCharEnd - 1), lineStartOffsets);
-            out.push({
-                content: slice,
-                chunkType: block.chunkType,
-                symbolPath: block.symbolSegments.join(' > '),
-                symbolSegments: block.symbolSegments,
-                symbolName: block.symbolName,
-                lineStart: lineStart,
-                lineEnd: lineEnd,
-                charStart: absoluteCharStart,
-                charEnd: absoluteCharEnd,
-                chunkIndex: out.length,
-                subChunkIndex: subChunkIndex,
-            });
-            subChunkIndex++;
-            if (end >= text.length) {
-                break;
-            }
-        }
-    }
-    /**
-     * Tiny / degenerált fallback: a teljes tartalmat egy (vagy nagy bemenetnél sliding) chunkba teszi.
-     * Soha nem ad vissza üres listát nem-üres bemenetre — a tartalom megőrzése a cél.
-     */
-    static buildFallbackChunks(content, sizing) {
-        const trimmed = content.trim();
-        if (!trimmed) {
-            return [];
-        }
-        const lineStartOffsets = this.computeLineStartOffsets(content);
-        // Kis tartalom → egyetlen fallback chunk.
-        if (content.length <= sizing.maxChunkSize) {
-            const lineEnd = this.lineOfOffset(Math.max(0, content.length - 1), lineStartOffsets);
-            return [{
-                    content: content,
-                    chunkType: 'fallback',
-                    symbolPath: '',
-                    symbolSegments: [],
-                    symbolName: undefined,
-                    lineStart: 1,
-                    lineEnd: lineEnd,
-                    charStart: 0,
-                    charEnd: content.length,
-                    chunkIndex: 0,
-                }];
-        }
-        // Nagy, de nem-parse-olható tartalom → sliding-window fallback.
-        const fallbackBlock = {
-            text: content,
-            chunkType: 'fallback',
-            symbolSegments: [],
-            symbolName: undefined,
-            charStart: 0,
-            charEnd: content.length,
-        };
-        const out = [];
-        this.splitLargeBlock(fallbackBlock, sizing, out, lineStartOffsets);
-        return out;
-    }
-    /**
-     * A forrás minden sorának kezdő karakter-offszetje (0-alapú). A `lineStartOffsets[i]` az `i`-edik
-     * (0-alapú) sor első karakterének abszolút pozíciója — bináris kereséssel gyors `offset → sor`
-     * konverziót ad a chunkokhoz.
-     */
-    static computeLineStartOffsets(source) {
-        const offsets = [0];
-        for (let i = 0; i < source.length; i++) {
-            if (source[i] === '\n') {
-                offsets.push(i + 1);
-            }
-        }
-        return offsets;
-    }
-    /**
-     * Egy abszolút karakter-offszet → 1-alapú sorszám a forrásban (bináris keresés a
-     * `lineStartOffsets`-ben). A sor-mezők így a forrás VALÓDI soraira mutatnak (nem chunk-relatív).
-     */
-    static lineOfOffset(offset, lineStartOffsets) {
-        let lo = 0;
-        let hi = lineStartOffsets.length - 1;
-        while (lo < hi) {
-            const mid = (lo + hi + 1) >> 1;
-            if (lineStartOffsets[mid] <= offset) {
-                lo = mid;
-            }
-            else {
-                hi = mid - 1;
-            }
-        }
-        return lo + 1;
-    }
-}
-exports.DyNTS_DAI_CodeChunking_Util = DyNTS_DAI_CodeChunking_Util;
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DyNTS_DAI_CodeChunking_Util = void 0;
+const tslib_1 = require("tslib");
+const ts = tslib_1.__importStar(require("typescript"));
+const fsm_dynamo_1 = require("@futdevpro/fsm-dynamo");
+/**
+ * `DyNTS_DAI_CodeChunking_Util` (BFR-AM-005) — **AST-pontos** TypeScript/JavaScript kód-chunker
+ * a TypeScript Compiler API-val (`ts.createSourceFile`). A FAM `FAM_TsChunker_Util` regex/brace-depth
+ * workaround-jának **bedrock-szintű, durable** változata: a `{`/`}` számolás helyett a valódi
+ * szintaxisfát járja be, így string-literálban / template-literálban / comment-ben lévő zárójelek
+ * NEM tévesztik meg.
+ *
+ * **Chunkolási stratégia (top-level node-onként, egy chunk per szemantikus egység):**
+ * - **import-group** — az összes egymást követő top-level `import` / `export ... from` egy chunkba
+ *   (a köztük lévő üres sorokkal együtt).
+ * - **class** — ha belefér a `maxChunkSize`-ba, az egész osztály egy chunk (dekorátorok + JSDoc-cal);
+ *   ha NEM fér bele, **metódusonként** bomlik (osztály-fej + minden metódus külön chunk, a
+ *   `class:Foo > method:bar` symbol-lánccal).
+ * - **interface / enum / type-alias / standalone function / top-level const(=>fn/value)** — egy chunk
+ *   per deklaráció.
+ * - **nagy node** (a fentiek közül bármelyik, ami a metódus-bontás UTÁN is `maxChunkSize` fölötti) →
+ *   karakter-alapú **sliding-window** sub-split (örökölt `chunkType` + symbol-lánc, `subChunkIndex`-szel).
+ * - **tiny / parse-degenerált tartalom** → egyetlen `fallback` chunk (a teljes forrás), hogy soha
+ *   ne vesszen el tartalom.
+ *
+ * A JSDoc + `@Decorator` MINDIG a következő node-dal együtt marad (a `node.getStart(sf, true)` a
+ * leading-JSDoc elejétől indul, a `ts.getDecorators` a node része).
+ *
+ * **headingPath = kód-symbol-lánc** (a markdown-chunker heading-láncának kód-megfelelője):
+ * `symbolPath` = a szegmensek ` > `-rel összefűzve.
+ */
+class DyNTS_DAI_CodeChunking_Util {
+    /** A FAM/CCAP-egyeztetett default méret-konstansok. */
+    static DEFAULT_MAX_CHUNK_SIZE = 1500;
+    static DEFAULT_OVERLAP = 100;
+    static DEFAULT_MIN_CHUNK_SIZE = 50;
+    /**
+     * Egy TS/JS forrás chunkolása szemantikus blokkok mentén a TS Compiler API AST-jával.
+     * Üres / whitespace-only tartalom → üres lista. A `maxChunkSize` fölötti node-ok sliding-window-ra
+     * bomlanak; a degenerált (parse-hiba / 0 blokk) esetet egyetlen `fallback` chunk fedi.
+     *
+     * @param code - A forráskód.
+     * @param opts - Méret-paraméterek (default 1500/100/50).
+     * @returns A szemantikus kód-chunkok listája (0-alapú `chunkIndex`-szel).
+     */
+    static chunkTs(code, opts) {
+        if (!code?.trim()) {
+            return [];
+        }
+        const sizing = this.resolveSizing(opts);
+        let blocks = [];
+        try {
+            const sourceFile = ts.createSourceFile('chunk-input.ts', code, ts.ScriptTarget.Latest, 
+            /* setParentNodes */ true, ts.ScriptKind.TSX);
+            blocks = this.identifyBlocks(sourceFile, code, sizing);
+        }
+        catch (error) {
+            // Parse-hiba (degenerált forrás) → a tiny-fallback veszi át lentebb.
+            fsm_dynamo_1.DyFM_Log.warn('DyNTS_DAI_CodeChunking_Util.chunkTs: AST parse failed, using fallback chunk', {
+                error: error?.message,
+            });
+            blocks = [];
+        }
+        // Tiny / degenerált esetek: ha nincs azonosított blokk, vagy a teljes forrás kicsi → egyetlen
+        // fallback chunk (soha ne vesszen el tartalom).
+        if (!blocks.length) {
+            return this.buildFallbackChunks(code, sizing);
+        }
+        // A sor-pozíciókhoz a teljes forrás sortörés-offszetjei (egyszer számolva).
+        const lineStartOffsets = this.computeLineStartOffsets(code);
+        const chunks = [];
+        for (const block of blocks) {
+            // Zaj-szűrés: CSAK a névtelen `generic` blokkokat dobjuk a minChunkSize alatt. A nevesített
+            // szemantikus deklarációk (type-alias / rövid function / class-fej / metódus / interface /
+            // enum / variable) MINDIG saját chunkot kapnak, méretüktől függetlenül — egy `type Id = string`
+            // teljes értékű egység. Az import-csoport sosem esik ki.
+            if (block.chunkType === 'generic' && block.text.trim().length < sizing.minChunkSize) {
+                continue;
+            }
+            if (block.text.length <= sizing.maxChunkSize) {
+                chunks.push(this.blockToChunk(block, chunks.length, lineStartOffsets));
+                continue;
+            }
+            // Túl nagy node → karakter-alapú sliding-window sub-split (örökölt symbol-lánc + chunkType).
+            this.splitLargeBlock(block, sizing, chunks, lineStartOffsets);
+        }
+        // Ha minden blokk kiesett a minChunkSize-szűrőn (pl. sok apró egysoros), essünk vissza a
+        // fallback-re, hogy ne adjunk vissza üres listát nem-üres bemenetre.
+        if (!chunks.length) {
+            return this.buildFallbackChunks(code, sizing);
+        }
+        return chunks;
+    }
+    /**
+     * Dispatcher: a `filename` kiterjesztése alapján a `.ts/.tsx/.js/.jsx/.mts/.cts/.mjs/.cjs`
+     * forrásokat az AST-chunkerre (`chunkTs`), minden mást (pl. `.md`) az adott formátum nyers
+     * sliding-fallback-jére irányít. A markdown-specifikus chunkolás a `DyNTS_DAI_DocChunking_Util`
+     * felelőssége (page-modell + parent-hierarchia kell hozzá), ezért azt itt NEM hívjuk —
+     * additív marad. Nem-kód input → `fallback` chunk a tartalom megőrzéséhez.
+     *
+     * @param content - A fájl tartalma.
+     * @param filename - A fájlnév (a kiterjesztés-alapú routinghoz).
+     * @param opts - Méret-paraméterek.
+     */
+    static chunk(content, filename, opts) {
+        if (this.isTsLike(filename)) {
+            return this.chunkTs(content, opts);
+        }
+        // Nem-kód (pl. .md / .txt / ismeretlen): nyers fallback chunkok — a tartalmat megőrizzük,
+        // de NEM próbáljuk szemantikusan darabolni (a markdown-darabolás külön util-é).
+        if (!content?.trim()) {
+            return [];
+        }
+        return this.buildFallbackChunks(content, this.resolveSizing(opts));
+    }
+    /** `true`, ha a fájlnév TS/JS-szerű (a `chunkTs` AST-parsere tudja kezelni). */
+    static isTsLike(filename) {
+        return /\.(ts|tsx|mts|cts|js|jsx|mjs|cjs)$/i.test(filename || '');
+    }
+    /** A default-ok feloldása (1500/100/50) + sanity-clamp. */
+    static resolveSizing(opts) {
+        const maxChunkSize = Math.max(1, opts?.maxChunkSize ?? this.DEFAULT_MAX_CHUNK_SIZE);
+        const overlap = Math.max(0, Math.min(opts?.overlap ?? this.DEFAULT_OVERLAP, maxChunkSize - 1));
+        const minChunkSize = Math.max(0, opts?.minChunkSize ?? this.DEFAULT_MIN_CHUNK_SIZE);
+        return { maxChunkSize: maxChunkSize, overlap: overlap, minChunkSize: minChunkSize };
+    }
+    /**
+     * AST-bejárás: a `SourceFile` top-level statement-jeit szemantikus blokkokká alakítja. Az
+     * egymást követő import-okat egy `imports` blokkba vonja össze. A `maxChunkSize` fölötti
+     * osztályt metódusonként bontja.
+     */
+    static identifyBlocks(sourceFile, code, sizing) {
+        const blocks = [];
+        // -- Import-csoport összevonás --
+        let importStart = -1;
+        let importEnd = -1;
+        const flushImports = () => {
+            if (importStart < 0) {
+                return;
+            }
+            const text = code.substring(importStart, importEnd);
+            if (text.trim().length) {
+                blocks.push({
+                    text: text,
+                    chunkType: 'imports',
+                    symbolSegments: [],
+                    symbolName: undefined,
+                    charStart: importStart,
+                    charEnd: importEnd,
+                });
+            }
+            importStart = -1;
+            importEnd = -1;
+        };
+        for (const statement of sourceFile.statements) {
+            if (this.isImportLike(statement)) {
+                const start = statement.getStart(sourceFile, /* includeJsDocComment */ true);
+                if (importStart < 0) {
+                    importStart = start;
+                }
+                importEnd = statement.getEnd();
+                continue;
+            }
+            // Más jött → import-csoport lezárása.
+            flushImports();
+            const detected = this.detectDeclaration(statement);
+            const start = statement.getStart(sourceFile, /* includeJsDocComment */ true);
+            const end = statement.getEnd();
+            const text = code.substring(start, end);
+            const symbolSegments = detected.name ? [`${detected.chunkType}:${detected.name}`] : [];
+            // Nagy osztály → metódusonkénti bontás (osztály-fej + metódusok).
+            if (ts.isClassDeclaration(statement) && text.length > sizing.maxChunkSize) {
+                this.splitClassByMethods(statement, sourceFile, code, detected.name, blocks);
+                continue;
+            }
+            blocks.push({
+                text: text,
+                chunkType: detected.chunkType,
+                symbolSegments: symbolSegments,
+                symbolName: detected.name,
+                charStart: start,
+                charEnd: end,
+            });
+        }
+        // Maradék import-csoport (ha a fájl import-tal végződik).
+        flushImports();
+        return blocks;
+    }
+    /** `true`, ha a statement import / re-export (`export ... from`) — az import-csoporthoz. */
+    static isImportLike(statement) {
+        if (ts.isImportDeclaration(statement) || ts.isImportEqualsDeclaration(statement)) {
+            return true;
+        }
+        // `export { ... } from '...'` / `export * from '...'` — csak ha van moduleSpecifier.
+        if (ts.isExportDeclaration(statement) && !!statement.moduleSpecifier) {
+            return true;
+        }
+        return false;
+    }
+    /** Egy top-level statement → szemantikus chunk-típus + symbol-név. */
+    static detectDeclaration(statement) {
+        if (ts.isClassDeclaration(statement)) {
+            return { chunkType: 'class', name: statement.name?.getText() };
+        }
+        if (ts.isInterfaceDeclaration(statement)) {
+            return { chunkType: 'interface', name: statement.name.getText() };
+        }
+        if (ts.isEnumDeclaration(statement)) {
+            return { chunkType: 'enum', name: statement.name.getText() };
+        }
+        if (ts.isTypeAliasDeclaration(statement)) {
+            return { chunkType: 'type', name: statement.name.getText() };
+        }
+        if (ts.isFunctionDeclaration(statement)) {
+            return { chunkType: 'function', name: statement.name?.getText() };
+        }
+        if (ts.isVariableStatement(statement)) {
+            const firstDecl = statement.declarationList.declarations[0];
+            const name = firstDecl && ts.isIdentifier(firstDecl.name)
+                ? firstDecl.name.getText()
+                : undefined;
+            // Ha a const egy függvény/arrow → 'function', egyébként 'variable'.
+            const initializer = firstDecl?.initializer;
+            const isFn = !!initializer
+                && (ts.isArrowFunction(initializer) || ts.isFunctionExpression(initializer));
+            return { chunkType: isFn ? 'function' : 'variable', name: name };
+        }
+        return { chunkType: 'generic', name: undefined };
+    }
+    /**
+     * Nagy osztály metódusonkénti bontása. Az első chunk az osztály-fej (a class-kulcsszótól az első
+     * tag előttig, dekorátorok + JSDoc-cal), majd minden metódus / property-deklaráció külön chunk a
+     * `class:Foo > method:bar` symbol-lánccal.
+     */
+    static splitClassByMethods(classDecl, sourceFile, code, className, blocks) {
+        const classSegment = `class:${className ?? 'anonymous'}`;
+        const classStart = classDecl.getStart(sourceFile, /* includeJsDocComment */ true);
+        const members = [...classDecl.members];
+        // Osztály-fej: a class kezdetétől az első tag kezdetéig (dekorátorok/JSDoc + `class X {`-rész).
+        const headerEnd = members.length
+            ? members[0].getStart(sourceFile, /* includeJsDocComment */ true)
+            : classDecl.getEnd();
+        const headerText = code.substring(classStart, headerEnd);
+        if (headerText.trim().length) {
+            blocks.push({
+                text: headerText,
+                chunkType: 'class',
+                symbolSegments: [classSegment],
+                symbolName: className,
+                charStart: classStart,
+                charEnd: headerEnd,
+            });
+        }
+        // Tagonkénti chunk (metódus / accessor / property).
+        for (const member of members) {
+            const memberStart = member.getStart(sourceFile, /* includeJsDocComment */ true);
+            const memberEnd = member.getEnd();
+            const memberText = code.substring(memberStart, memberEnd);
+            if (!memberText.trim().length) {
+                continue;
+            }
+            const memberName = member.name && ts.isIdentifier(member.name)
+                ? member.name.getText()
+                : (member.name ? member.name.getText() : undefined);
+            const memberKind = this.classMemberKind(member);
+            const memberSegment = memberName
+                ? `${memberKind}:${memberName}`
+                : memberKind;
+            blocks.push({
+                text: memberText,
+                chunkType: memberKind,
+                symbolSegments: [classSegment, memberSegment],
+                symbolName: memberName,
+                charStart: memberStart,
+                charEnd: memberEnd,
+            });
+        }
+    }
+    /** Egy osztály-tag → chunk-típus (metódus/accessor → 'method', mező → 'variable'). */
+    static classMemberKind(member) {
+        if (ts.isMethodDeclaration(member)
+            || ts.isConstructorDeclaration(member)
+            || ts.isGetAccessorDeclaration(member)
+            || ts.isSetAccessorDeclaration(member)) {
+            return 'method';
+        }
+        return 'variable';
+    }
+    /** Egy belső blokk → `DyNTS_DAI_CodeChunk` (pozíció + symbol-lánc kiszámolásával). */
+    static blockToChunk(block, chunkIndex, lineStartOffsets) {
+        const lineStart = this.lineOfOffset(block.charStart, lineStartOffsets);
+        const lineEnd = this.lineOfOffset(Math.max(block.charStart, block.charEnd - 1), lineStartOffsets);
+        return {
+            content: block.text,
+            chunkType: block.chunkType,
+            symbolPath: block.symbolSegments.join(' > '),
+            symbolSegments: block.symbolSegments,
+            symbolName: block.symbolName,
+            lineStart: lineStart,
+            lineEnd: lineEnd,
+            charStart: block.charStart,
+            charEnd: block.charEnd,
+            chunkIndex: chunkIndex,
+        };
+    }
+    /**
+     * Túl nagy blokk karakter-alapú sliding-window sub-splitje (örökölt chunkType + symbol-lánc).
+     * Az átfedés (`overlap`) karakter-szinten, a `minChunkSize` alatti farok-chunkokat kihagyja.
+     */
+    static splitLargeBlock(block, sizing, out, lineStartOffsets) {
+        const text = block.text;
+        const step = Math.max(1, sizing.maxChunkSize - sizing.overlap);
+        let subChunkIndex = 0;
+        for (let start = 0; start < text.length; start += step) {
+            const end = Math.min(start + sizing.maxChunkSize, text.length);
+            const slice = text.substring(start, end);
+            // A nagyon kicsi farok-chunkot (az utolsó, ami már nem éri el a minChunkSize-t) kihagyjuk,
+            // de csak ha NEM ez az egyetlen chunk.
+            if (slice.trim().length < sizing.minChunkSize && subChunkIndex > 0) {
+                break;
+            }
+            const absoluteCharStart = block.charStart + start;
+            const absoluteCharEnd = block.charStart + end;
+            const lineStart = this.lineOfOffset(absoluteCharStart, lineStartOffsets);
+            const lineEnd = this.lineOfOffset(Math.max(absoluteCharStart, absoluteCharEnd - 1), lineStartOffsets);
+            out.push({
+                content: slice,
+                chunkType: block.chunkType,
+                symbolPath: block.symbolSegments.join(' > '),
+                symbolSegments: block.symbolSegments,
+                symbolName: block.symbolName,
+                lineStart: lineStart,
+                lineEnd: lineEnd,
+                charStart: absoluteCharStart,
+                charEnd: absoluteCharEnd,
+                chunkIndex: out.length,
+                subChunkIndex: subChunkIndex,
+            });
+            subChunkIndex++;
+            if (end >= text.length) {
+                break;
+            }
+        }
+    }
+    /**
+     * Tiny / degenerált fallback: a teljes tartalmat egy (vagy nagy bemenetnél sliding) chunkba teszi.
+     * Soha nem ad vissza üres listát nem-üres bemenetre — a tartalom megőrzése a cél.
+     */
+    static buildFallbackChunks(content, sizing) {
+        const trimmed = content.trim();
+        if (!trimmed) {
+            return [];
+        }
+        const lineStartOffsets = this.computeLineStartOffsets(content);
+        // Kis tartalom → egyetlen fallback chunk.
+        if (content.length <= sizing.maxChunkSize) {
+            const lineEnd = this.lineOfOffset(Math.max(0, content.length - 1), lineStartOffsets);
+            return [{
+                    content: content,
+                    chunkType: 'fallback',
+                    symbolPath: '',
+                    symbolSegments: [],
+                    symbolName: undefined,
+                    lineStart: 1,
+                    lineEnd: lineEnd,
+                    charStart: 0,
+                    charEnd: content.length,
+                    chunkIndex: 0,
+                }];
+        }
+        // Nagy, de nem-parse-olható tartalom → sliding-window fallback.
+        const fallbackBlock = {
+            text: content,
+            chunkType: 'fallback',
+            symbolSegments: [],
+            symbolName: undefined,
+            charStart: 0,
+            charEnd: content.length,
+        };
+        const out = [];
+        this.splitLargeBlock(fallbackBlock, sizing, out, lineStartOffsets);
+        return out;
+    }
+    /**
+     * A forrás minden sorának kezdő karakter-offszetje (0-alapú). A `lineStartOffsets[i]` az `i`-edik
+     * (0-alapú) sor első karakterének abszolút pozíciója — bináris kereséssel gyors `offset → sor`
+     * konverziót ad a chunkokhoz.
+     */
+    static computeLineStartOffsets(source) {
+        const offsets = [0];
+        for (let i = 0; i < source.length; i++) {
+            if (source[i] === '\n') {
+                offsets.push(i + 1);
+            }
+        }
+        return offsets;
+    }
+    /**
+     * Egy abszolút karakter-offszet → 1-alapú sorszám a forrásban (bináris keresés a
+     * `lineStartOffsets`-ben). A sor-mezők így a forrás VALÓDI soraira mutatnak (nem chunk-relatív).
+     */
+    static lineOfOffset(offset, lineStartOffsets) {
+        let lo = 0;
+        let hi = lineStartOffsets.length - 1;
+        while (lo < hi) {
+            const mid = (lo + hi + 1) >> 1;
+            if (lineStartOffsets[mid] <= offset) {
+                lo = mid;
+            }
+            else {
+                hi = mid - 1;
+            }
+        }
+        return lo + 1;
+    }
+}
+exports.DyNTS_DAI_CodeChunking_Util = DyNTS_DAI_CodeChunking_Util;
 //# sourceMappingURL=dai-code-chunking.util.js.map