@futdevpro/fdp-agent-memory 0.1.0

package/build/src/_modules/embedding/_services/fam-embedding-cost.control-service.js

@@ -0,0 +1,175 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.FAM_EmbeddingCost_ControlService = void 0;
+const config_control_service_1 = require("../../../_routes/server/config/config.control-service");
+const fam_embedding_pricing_const_1 = require("../_collections/fam-embedding-pricing.const");
+/**
+ * `FAM_EmbeddingCost_ControlService` (SP-2.4, dsgn-006 §7) — **BFR-AM-007 projekt-lokális workaround**:
+ * embedding-költség hívás-típusonkénti aggregálása + a per-call cost-cap (`block-before-overrun` +
+ * `warn`). Singleton, in-memory aggregátor (a `run`-window az aktuális process-futás).
+ *
+ * **Token-becslés** (a Dynamo nem ad pontos token-számot a hívás ELŐTT): a szöveg-hossz / `CHARS_PER_TOKEN`
+ * heurisztika. Konzervatív (inkább túlbecsül), hogy a cap NE csússzon át túllépésbe. A tényleges
+ * token-fogyasztást a cost-event-ből (`recordActual`) korrigáljuk a hívás UTÁN.
+ *
+ * **Cost-cap precedencia:** a `embedding.costCapUsd` / `costCapWarnRatio` / `costWindow` a config-
+ * precedencián (`scope > table > global > builtin`) oldódik fel (dsgn-007 §4.4). `null` cap = nincs plafon.
+ */
+class FAM_EmbeddingCost_ControlService {
+    static _instance;
+    /** Az aktuális process-futás (`run`-window) hívás-típusonkénti aggregátuma. */
+    runBuckets = this.emptyBuckets();
+    static getInstance() {
+        if (!FAM_EmbeddingCost_ControlService._instance) {
+            FAM_EmbeddingCost_ControlService._instance = new FAM_EmbeddingCost_ControlService();
+        }
+        return FAM_EmbeddingCost_ControlService._instance;
+    }
+    // =========================================================================
+    // COST-CAP precheck (dsgn-006 §7) — a hívás ELŐTT
+    // =========================================================================
+    /**
+     * A cost-cap döntés a hívás ELŐTT (dsgn-006 §7). A becsült költséget (a `texts`-ből) hozzáadja az
+     * aktuális window-aggregátumhoz: ha `>= capUsd` → `blocked` (a `FAM_Embedding_ControlService`
+     * `FAM-EMB-COSTCAP-001`-et emittál); ha `>= capUsd * warnRatio` → `warn` (nem blokkol). `null` cap
+     * (vagy lokális provider) → soha nem blokkol/warn-ol.
+     */
+    async precheck(context) {
+        const estimatedTokens = this.estimateTokens(context.texts);
+        const estimatedUsd = this.estimateUsd(context.provider, context.modelId, estimatedTokens);
+        const capUsd = await this.resolveCap('embedding.costCapUsd', context);
+        const warnRatio = (await this.resolveNumber('embedding.costCapWarnRatio', context)) ?? 0.8;
+        const windowKey = (await this.resolveWindow(context)) ?? 'run';
+        // Lokális provider (LM Studio / mock) → nincs USD-költség (dsgn-006 §7): soha nem blokkol.
+        const aggregatedUsd = this.windowAggregatedUsd(windowKey);
+        const projectedUsd = aggregatedUsd + estimatedUsd;
+        if (capUsd === null || capUsd <= 0) {
+            return {
+                blocked: false, warn: false, projectedUsd: projectedUsd, capUsd: capUsd,
+                reason: 'Nincs konfigurált embedding cost-plafon (embedding.costCapUsd = null).',
+            };
+        }
+        if (projectedUsd >= capUsd) {
+            return {
+                blocked: true, warn: false, projectedUsd: projectedUsd, capUsd: capUsd,
+                reason: `A következő embedding-hívás túllépné a(z) $${capUsd} plafont `
+                    + `(aggregált $${aggregatedUsd.toFixed(6)} + becsült $${estimatedUsd.toFixed(6)} = `
+                    + `$${projectedUsd.toFixed(6)}, window=${windowKey}).`,
+            };
+        }
+        if (projectedUsd >= capUsd * warnRatio) {
+            return {
+                blocked: false, warn: true, projectedUsd: projectedUsd, capUsd: capUsd,
+                reason: `Az embedding-költség közelít a(z) $${capUsd} plafonhoz `
+                    + `(${(projectedUsd / capUsd * 100).toFixed(0)}%, window=${windowKey}).`,
+            };
+        }
+        return {
+            blocked: false, warn: false, projectedUsd: projectedUsd, capUsd: capUsd,
+            reason: 'A becsült költség a warn-küszöb alatt.',
+        };
+    }
+    // =========================================================================
+    // AGGREGÁCIÓ — a hívás UTÁN (cost-event / becslés)
+    // =========================================================================
+    /**
+     * A tényleges költség rögzítése a hívás UTÁN (a cost-event token-fogyasztásából, vagy ha az nem
+     * érkezik — pl. LM Studio/mock — a becsült tokenből). A `FAM_Embedding_ControlService` hívja a
+     * sikeres embed után. A `provider` lokális → `estimatedCostUsd=0`, csak token-telemetria.
+     */
+    recordActual(set) {
+        const usd = this.estimateUsd(set.provider, set.modelId, set.tokens);
+        const bucket = this.runBuckets[set.callType];
+        bucket.tokens += set.tokens;
+        bucket.estimatedCostUsd += usd;
+        bucket.calls += 1;
+    }
+    /**
+     * A teljes cost-stats (a `get_embedding_cost_stats` capability — dsgn-003 — kimenete). Hívás-
+     * típusonkénti bontás + összesítés. A `run`-window az aktuális process-futás aggregátuma.
+     */
+    getStats() {
+        let totalTokens = 0;
+        let totalUsd = 0;
+        for (const callType of Object.keys(this.runBuckets)) {
+            totalTokens += this.runBuckets[callType].tokens;
+            totalUsd += this.runBuckets[callType].estimatedCostUsd;
+        }
+        return {
+            byCallType: this.cloneBuckets(),
+            totalTokens: totalTokens,
+            totalEstimatedCostUsd: totalUsd,
+        };
+    }
+    /** Az aggregátum nullázása (teszt-izoláció + a `run`-window reset). */
+    reset() {
+        this.runBuckets = this.emptyBuckets();
+    }
+    // =========================================================================
+    // becslés + helpers
+    // =========================================================================
+    /** Token-becslés a szövegek összhosszából (~4 char/token heurisztika; konzervatív felfelé). */
+    estimateTokens(texts) {
+        const totalChars = texts.reduce((sum, text) => sum + (text?.length ?? 0), 0);
+        return Math.ceil(totalChars / fam_embedding_pricing_const_1.FAM_EMBEDDING_CHARS_PER_TOKEN);
+    }
+    /** A becsült USD egy adott token-számra (lokális provider → 0; OpenAI → ár-tábla / fallback). */
+    estimateUsd(provider, modelId, tokens) {
+        if (provider !== 'openai') {
+            return 0;
+        }
+        const pricePer1k = fam_embedding_pricing_const_1.FAM_EMBEDDING_PRICE_PER_1K_TOKENS[modelId] ?? fam_embedding_pricing_const_1.FAM_EMBEDDING_DEFAULT_OPENAI_PRICE_PER_1K;
+        return (tokens / 1000) * pricePer1k;
+    }
+    /** Az adott window aggregált USD-je. MVP1: a `run`-window az in-memory aggregátum; `day`/`total`
+     *  szintén ezt használja (a perzistált window-aggregátor a bedrock cost-store-ral jön — BFR-AM-007). */
+    windowAggregatedUsd(_window) {
+        let total = 0;
+        for (const callType of Object.keys(this.runBuckets)) {
+            total += this.runBuckets[callType].estimatedCostUsd;
+        }
+        return total;
+    }
+    /** A `costCapUsd` (number-or-null) feloldása a config-precedencián. */
+    async resolveCap(key, context) {
+        const resolved = await config_control_service_1.FAM_Config_ControlService.getInstance().resolve(key, {
+            table: context.table, scopePath: context.scopePath,
+        });
+        return typeof resolved.value === 'number' ? resolved.value : null;
+    }
+    /** Egy number config feloldása (warn-ratio); ha nem number → null. */
+    async resolveNumber(key, context) {
+        const resolved = await config_control_service_1.FAM_Config_ControlService.getInstance().resolve(key, {
+            table: context.table, scopePath: context.scopePath,
+        });
+        return typeof resolved.value === 'number' ? resolved.value : null;
+    }
+    /** A `costWindow` feloldása (string enum). */
+    async resolveWindow(context) {
+        const resolved = await config_control_service_1.FAM_Config_ControlService.getInstance().resolve('embedding.costWindow', {
+            table: context.table, scopePath: context.scopePath,
+        });
+        if (resolved.value === 'run' || resolved.value === 'day' || resolved.value === 'total') {
+            return resolved.value;
+        }
+        return null;
+    }
+    /** Üres aggregátum minden hívás-típusra. */
+    emptyBuckets() {
+        return {
+            'embed-write': { tokens: 0, estimatedCostUsd: 0, calls: 0 },
+            'embed-scan': { tokens: 0, estimatedCostUsd: 0, calls: 0 },
+            'embed-re-embed': { tokens: 0, estimatedCostUsd: 0, calls: 0 },
+            'embed-query': { tokens: 0, estimatedCostUsd: 0, calls: 0 },
+        };
+    }
+    /** Az aggregátum másolata (a `getStats` ne adjon élő referenciát). */
+    cloneBuckets() {
+        const result = this.emptyBuckets();
+        for (const callType of Object.keys(this.runBuckets)) {
+            result[callType] = { ...this.runBuckets[callType] };
+        }
+        return result;
+    }
+}
+exports.FAM_EmbeddingCost_ControlService = FAM_EmbeddingCost_ControlService;

package/build/src/_modules/embedding/_services/fam-embedding-pipeline.control-service.js

@@ -0,0 +1,202 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.FAM_EmbeddingPipeline_ControlService = void 0;
+const tslib_1 = require("tslib");
+const crypto = tslib_1.__importStar(require("crypto"));
+const fsm_dynamo_1 = require("@futdevpro/fsm-dynamo");
+const error_codes_const_1 = require("../../../_collections/error-codes.const");
+const errors_control_service_1 = require("../../../_routes/server/errors/errors.control-service");
+const fam_store_registry_const_1 = require("../_collections/fam-store-registry.const");
+const fam_embedding_control_service_1 = require("./fam-embedding.control-service");
+const fam_entry_data_service_1 = require("./fam-entry.data-service");
+const fam_vector_search_control_service_1 = require("./fam-vector-search.control-service");
+/**
+ * `FAM_EmbeddingPipeline_ControlService` (SP-2.2 auto-embed + SP-2.4 re-embed) — az embedding-réteg
+ * írás-oldali orchestrátora. Singleton. Két fő belépési pont:
+ *
+ * 1. **`embedAndPersist`** (auto-embed; dsgn-006 §3) — a write/scan path mentés UTÁN ezt hívja egy
+ *    entry-re (MP-4/MP-5): `contentHash` → embed (provider-agnosztikus) → `contentVector` + `embeddingModel`
+ *    + `embeddingStatus='completed'` atomikus `$set` → LVS pool upsert. Hiba → `embeddingStatus='error'`
+ *    + `FAM_Error` (dsgn-008), az entry NEM kerül a keresésbe.
+ * 2. **`reEmbedTable` / `reEmbedScope`** (re-embed; dsgn-006 §5) — modell-/provider-váltáskor a meglévő
+ *    vektorok frissítése az aktuális modellre, kötegelten (flow-limit), `pending→completed/error`
+ *    lifecycle-lel, LVS pool re-hidratálással. Eredmény `{ reembedded, skipped, failed }`.
+ *
+ * **AUTO-EMBED-ON-SAVE DÖNTÉS (dsgn-006 §3, lásd a modul-README-t):** a Dynamo `DyNTS_OAI_VectorDataService.saveData`
+ * auto-vektorizál a `vectorizedFrom` annotációból, DE hardwired OpenAI-ra (`DyFM_OAI_Settings` + OpenAI-kliens),
+ * és NINCS globális provider-agnosztikus embedding-hook a `DyNTS_DataService.saveData`-ban. Ezért a FAM az
+ * embeddinget EXPLICIT pipeline-on (ez a service) végzi — a `FAM_Embedding_ControlService` provider-dispatch-én
+ * át (OpenAI/LM Studio/mock) — NEM a Dynamo auto-vektorizáláson. Így a `vectorizedFrom` annotáció a forrás-mező-
+ * jelölés szerepét tölti be (a content-kompozícióhoz), az embedding-hívás viszont a FAM kapuján megy.
+ */
+class FAM_EmbeddingPipeline_ControlService {
+    static _instance;
+    issuer = 'FAM_EmbeddingPipeline_ControlService';
+    /** A re-embed flow-limit felső korlátja (CCAP MAX 200; dsgn-007 §4.7). */
+    maxFlowLimit = 200;
+    static getInstance() {
+        if (!FAM_EmbeddingPipeline_ControlService._instance) {
+            FAM_EmbeddingPipeline_ControlService._instance = new FAM_EmbeddingPipeline_ControlService();
+        }
+        return FAM_EmbeddingPipeline_ControlService._instance;
+    }
+    // =========================================================================
+    // AUTO-EMBED (dsgn-006 §3) — write/scan path mentés után
+    // =========================================================================
+    /**
+     * Egy entry embeddelése + persist + pool-upsert (dsgn-006 §3). A write/scan path (MP-4/MP-5) hívja a
+     * Mongo-mentés UTÁN (az entry már létezik `_id`-vel). A flow: content-kompozíció (`vectorizedFrom`) →
+     * `contentHash` → embed → atomikus `$set` (`contentVector`+`embeddingModel`+`completed`) → pool upsert.
+     * Hiba → `embeddingStatus='error'` + `FAM_Error` (a hívónak visszaadott eredmény jelzi a státuszt).
+     */
+    async embedAndPersist(set) {
+        const registryEntry = fam_store_registry_const_1.FAM_StoreRegistry_Util.getEntry(set.table);
+        if (!registryEntry || !set.entry._id) {
+            return { status: 'error', dims: 0 };
+        }
+        const dataService = new fam_entry_data_service_1.FAM_Entry_DataService({ dataParams: registryEntry.dataParams, issuer: this.issuer });
+        const composed = this.composeVectorizedText(set.entry, registryEntry.vectorizedFrom);
+        const contentHash = this.sha256(composed);
+        if (!composed.trim().length) {
+            // Nincs vektorizálható content → marad pending (a write-validáció a content-kötelezőséget
+            // külön kezeli; itt csak jelezzük, hogy nincs mit embeddelni).
+            return { status: 'error', dims: 0 };
+        }
+        try {
+            const vectors = await fam_embedding_control_service_1.FAM_Embedding_ControlService.getInstance().embedTexts({
+                texts: [composed],
+                table: set.table,
+                scopePath: set.entry.scopePath,
+                callType: set.callType ?? 'embed-write',
+                issuer: this.issuer,
+            });
+            const vector = vectors[0] ?? [];
+            const resolved = await fam_embedding_control_service_1.FAM_Embedding_ControlService.getInstance().resolveProvider({
+                table: set.table, scopePath: set.entry.scopePath,
+            });
+            await dataService.setVector({
+                id: set.entry._id,
+                contentVector: vector,
+                embeddingModel: resolved.modelId,
+                embeddingStatus: 'completed',
+                contentHash: contentHash,
+            });
+            fam_vector_search_control_service_1.FAM_VectorSearch_ControlService.getInstance().upsertVector({ table: set.table, id: set.entry._id, vector: vector });
+            return { status: 'completed', dims: vector.length };
+        }
+        catch (error) {
+            // No-silent-failure: az entry `error`-státuszba kerül + a hiba persistált; a pool-ból kivesszük.
+            await dataService.setEmbeddingStatus(set.entry._id, 'error');
+            fam_vector_search_control_service_1.FAM_VectorSearch_ControlService.getInstance().removeVector(set.table, set.entry._id);
+            await errors_control_service_1.FAM_Error_ControlService.getInstance().emit({
+                errorCode: error_codes_const_1.FAM_ERROR_CODES.embProviderUnreachable,
+                message: `Az entry embeddelése sikertelen (table='${set.table}', id='${set.entry._id}').`,
+                cause: error,
+                context: { operation: 'embed-and-persist', table: set.table },
+            });
+            return { status: 'error', dims: 0 };
+        }
+    }
+    // =========================================================================
+    // RE-EMBED (dsgn-006 §5) — modell-/provider-váltás
+    // =========================================================================
+    /**
+     * Egy teljes tár re-embed-je (dsgn-006 §5). A `completed`/`error`/`pending` cél-entry-ket (`!_deleted`)
+     * kötegelten (flow-limit) újra-embeddeli az AKTUÁLIS modellre: `pending` → `embed` → `contentVector` +
+     * `embeddingModel` frissítés → `completed`/`error` → LVS pool upsert. Az `addedBy='re-embed'` provenance
+     * a hívó write-path-é (itt a vektor-frissítésre fókuszálunk). Eredmény `{ reembedded, skipped, failed }`.
+     */
+    async reEmbedTable(table, flowLimit) {
+        return this.reEmbed({ table: table, flowLimit: flowLimit });
+    }
+    /**
+     * Egy tár adott scope-ágának re-embed-je (dsgn-006 §5). A scope-prefiltert MP-3/MP-5 adja (a
+     * `scopeId`-halmaz); itt a `scopePath` LEVÉL scopeId-jára szűkítünk (a `scopePath.scopeId` mező
+     * indexelt — a write-path canonical scopePath-ot ír az entry-re).
+     */
+    async reEmbedScope(table, scopePath, flowLimit) {
+        return this.reEmbed({ table: table, scopePath: scopePath, flowLimit: flowLimit });
+    }
+    /** A re-embed mag (table + opc. scope-szűkítés). Re-hidratálja az érintett pool-t a frissített vektorral. */
+    async reEmbed(set) {
+        const registryEntry = fam_store_registry_const_1.FAM_StoreRegistry_Util.getEntry(set.table);
+        const result = {
+            table: set.table,
+            scopePath: set.scopePath?.map((ref) => ref.canonicalName).join('>'),
+            total: 0, reembedded: 0, skipped: 0, failed: 0,
+        };
+        if (!registryEntry) {
+            return result;
+        }
+        const dataService = new fam_entry_data_service_1.FAM_Entry_DataService({ dataParams: registryEntry.dataParams, issuer: this.issuer });
+        const filter = this.buildScopeFilter(set.scopePath);
+        const targets = await dataService.findHydratableList(filter);
+        result.total = targets.length;
+        const flowLimit = Math.min(Math.max(set.flowLimit ?? 20, 1), this.maxFlowLimit);
+        // Kötegelt feldolgozás (flow-limit; rate-/token-limit védelem, dsgn-006 §5).
+        for (let i = 0; i < targets.length; i += flowLimit) {
+            const batch = targets.slice(i, i + flowLimit);
+            await Promise.all(batch.map((entry) => this.reEmbedOne(set.table, entry, registryEntry, dataService, result)));
+        }
+        fsm_dynamo_1.DyFM_Log.log(`[FAM re-embed] '${set.table}'${result.scopePath ? ` (scope=${result.scopePath})` : ''}: `
+            + `total=${result.total} reembedded=${result.reembedded} skipped=${result.skipped} failed=${result.failed}`);
+        return result;
+    }
+    /** Egy entry re-embed-je (pending → embed → completed/error → pool upsert). Mutálja a `result`-ot. */
+    async reEmbedOne(table, entry, registryEntry, dataService, result) {
+        if (!entry._id) {
+            result.skipped++;
+            return;
+        }
+        const composed = this.composeVectorizedText(entry, registryEntry.vectorizedFrom);
+        if (!composed.trim().length) {
+            result.skipped++;
+            return;
+        }
+        await dataService.setEmbeddingStatus(entry._id, 'pending');
+        const outcome = await this.embedAndPersist({ table: table, entry: entry, callType: 'embed-re-embed' });
+        if (outcome.status === 'completed') {
+            result.reembedded++;
+        }
+        else {
+            result.failed++;
+        }
+    }
+    // =========================================================================
+    // content-kompozíció + hash + scope-filter
+    // =========================================================================
+    /**
+     * A vektorizálandó szöveg összeállítása a `vectorizedFrom` forrás-mezőkből (dsgn-001 §8, dsgn-006 §3).
+     * Pl. knowledge: `content` + `subject` + `description`. A nem-string / üres mezőket kihagyja; a
+     * mezőket sortöréssel fűzi (a szemantikai jel maximalizálásához). A `FAM_Entry` dinamikus mező-
+     * olvasását `Reflect.get`-tel végzi (a per-tár mezők — pl. `subject` — nincsenek a bázis-shape-en).
+     */
+    composeVectorizedText(entry, vectorizedFrom) {
+        const parts = [];
+        for (const field of vectorizedFrom) {
+            const value = Reflect.get(entry, field);
+            if (typeof value === 'string' && value.trim().length) {
+                parts.push(value.trim());
+            }
+        }
+        return parts.join('\n');
+    }
+    /** SHA-256(normalizált szöveg) — a delta-detection contentHash-e (dsgn-001 / dsgn-004 §4). */
+    sha256(text) {
+        return crypto.createHash('sha256').update(this.normalize(text)).digest('hex');
+    }
+    /** Egyszerű normalizálás a hash-hez (whitespace-tömörítés + trim) — a delta-konzisztenciához. */
+    normalize(text) {
+        return text.replace(/\s+/g, ' ').trim();
+    }
+    /** A scope-szűkítő filter (a `scopePath` LEVÉL scopeId-jára). Üres scope → teljes tár (`!_deleted`). */
+    buildScopeFilter(scopePath) {
+        if (scopePath && scopePath.length) {
+            const leaf = scopePath[scopePath.length - 1];
+            const filter = { 'scopePath.scopeId': leaf.scopeId };
+            return filter;
+        }
+        return {};
+    }
+}
+exports.FAM_EmbeddingPipeline_ControlService = FAM_EmbeddingPipeline_ControlService;

package/build/src/_modules/embedding/_services/fam-embedding-preset.control-service.js

@@ -0,0 +1,66 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.FAM_EmbeddingPreset_ControlService = void 0;
+const config_control_service_1 = require("../../../_routes/server/config/config.control-service");
+const fam_embedding_control_service_1 = require("./fam-embedding.control-service");
+/**
+ * `FAM_EmbeddingPreset_ControlService` (SP-2.3, dsgn-006 §6) — az embedding-presetek + per-tár/scope
+ * modell-override embedding-lencséje. Singleton. A preset-bundle SSOT-ja a MP-7 `CONFIG_PRESETS`; az
+ * `applyPreset` a MP-7 `FAM_Config_ControlService.applyPreset`-re delegál (rendes `FAM_Config` rekordok,
+ * `setBy='preset'`, atomikus + validált — dsgn-007 §5). EZ a service a `fam init` / CLI (MP-9/12) felé
+ * adott embedding-orientált belépési pont (preset-felajánlás + override-helper).
+ *
+ * **A dimenzió-eltérés → re-embed jelzés** (acceptance #6): a preset/override dimenzió-váltása (pl.
+ * global OpenAI 3072 → table LM Studio 768) re-embedet igényel — a `wouldRequireReEmbed` ezt jelzi a
+ * hívónak (a tényleges re-embedet a `FAM_EmbeddingPipeline_ControlService.reEmbedTable` futtatja).
+ */
+class FAM_EmbeddingPreset_ControlService {
+    static _instance;
+    issuer = 'FAM_EmbeddingPreset_ControlService';
+    static getInstance() {
+        if (!FAM_EmbeddingPreset_ControlService._instance) {
+            FAM_EmbeddingPreset_ControlService._instance = new FAM_EmbeddingPreset_ControlService();
+        }
+        return FAM_EmbeddingPreset_ControlService._instance;
+    }
+    /** A felajánlható beépített preset-nevek (a `fam init` / `create-config` ezt listázza — dsgn-006 §6). */
+    availablePresets() {
+        return ['openai-recommended', 'lmstudio-recommended'];
+    }
+    /**
+     * Egy preset alkalmazása (MP-7-re delegálva). `table` nélkül → table-szint kötelező (a MP-7 validál);
+     * `scopeId`-val → scope-szint. Idempotens + atomikus (egy invalid kulcs → semmi nem íródik, dsgn-007 §5).
+     * Pl. a nagy `codebase` tár `lmstudio-recommended`-et kaphat table-szinten, míg a global OpenAI marad.
+     */
+    async applyPreset(set) {
+        return config_control_service_1.FAM_Config_ControlService.getInstance().applyPreset(set.name, {
+            table: set.table,
+            scopeId: set.scopeId,
+            issuer: set.issuer ?? this.issuer,
+        });
+    }
+    /**
+     * A jelenleg feloldott embedding-provider egy kontextusra (a `get_embedding_config` capability —
+     * dsgn-003). A per-tár/scope override-ot a `FAM_Embedding_ControlService.resolveProvider` adja vissza.
+     */
+    async getResolvedProvider(set) {
+        return fam_embedding_control_service_1.FAM_Embedding_ControlService.getInstance().resolveProvider({ table: set.table, scopePath: set.scopePath });
+    }
+    /**
+     * Re-embed szükséges-e egy tervezett modell-/dimenzió-váltáshoz (acceptance #6)? A jelenlegi
+     * feloldott dimenziót összeveti a tervezett `targetDims`-szel: eltérés → `true` (a pool nem keverhet
+     * eltérő dimenziót; a hívónak re-embedet kell futtatnia). `null` (natív) dim → nem dönthető el
+     * statikusan (`false`, a tényleges modell-dim a hívás-időpontban derül ki).
+     */
+    async wouldRequireReEmbed(set) {
+        if (set.targetDims === null) {
+            return false;
+        }
+        const current = await this.getResolvedProvider({ table: set.table, scopePath: set.scopePath });
+        if (current.dims === null) {
+            return false;
+        }
+        return current.dims !== set.targetDims;
+    }
+}
+exports.FAM_EmbeddingPreset_ControlService = FAM_EmbeddingPreset_ControlService;