noteconnection 1.8.0 → 1.9.0

package/dist/src/learning/ragPublicText.test.js

@@ -0,0 +1,57 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const ragPublicText_1 = require("./ragPublicText");
+const KnowledgeLearningPlatform_1 = require("./KnowledgeLearningPlatform");
+describe('ragPublicText', () => {
+    test('retains numbered procedure evidence for a how-should request', () => {
+        expect((0, ragPublicText_1.shouldRejectCompareProcedureEvidenceClause)('Step 1: Validate the candidate.', 'How should the index be replaced?')).toBe(false);
+        expect((0, ragPublicText_1.shouldRejectCompareProcedureEvidenceClause)('Step 1: Validate the candidate.', 'Compare the two indexes.')).toBe(true);
+    });
+    test.each(['[[Checkpoint]]', '[[Checkpoint]] [[Mutation log]]', '1. [[Checkpoint]] 2. [[Mutation log]]'])('rejects link-only navigation as factual evidence: %s', text => {
+        expect((0, ragPublicText_1.shouldRejectPublicEvidenceClause)(text)).toBe(true);
+    });
+    test('preserves factual prose that contains a wiki link', () => {
+        expect((0, ragPublicText_1.shouldRejectPublicEvidenceClause)('A [[Mutation log]] records an ordered sequence of changes.')).toBe(false);
+    });
+    test('comparison composition selects source facts instead of bare wiki links', async () => {
+        const platform = new KnowledgeLearningPlatform_1.KnowledgeLearningPlatform({ autoPersist: false });
+        await platform.ingestKnowledge({ documents: [
+                { documentId: 'checkpoint', sourcePath: 'test/checkpoint.md', content: '# Checkpoint\nA checkpoint stores the complete state at a checkpoint. [[Mutation log]]' },
+                { documentId: 'mutation-log', sourcePath: 'test/mutation-log.md', content: '# Mutation Log\nA mutation log records an ordered sequence of state changes. [[Checkpoint]]' },
+            ] });
+        const response = await platform.agentConversation({ message: 'Compare Checkpoint and Mutation Log', persistMemory: false });
+        expect(response.answer).toMatch(/complete state|ordered sequence/i);
+        expect((0, ragPublicText_1.shouldRejectPublicEvidenceClause)(response.answer)).toBe(false);
+    });
+    test('removes Markdown list and bold-label scaffolding before public composition', () => {
+        expect((0, ragPublicText_1.naturalizeRagPublicEvidenceClause)('* **Quantitative analysis**: pressure follows P = rho g h.'))
+            .toBe('Quantitative analysis: pressure follows P = rho g h.');
+        expect((0, ragPublicText_1.naturalizeRagPublicEvidenceClause)('* $T$ is the temperature field.'))
+            .toBe('$T$ is the temperature field.');
+        expect((0, ragPublicText_1.naturalizeRagPublicEvidenceClause)('A value * B value remains mathematical.'))
+            .toBe('A value * B value remains mathematical.');
+    });
+    test('removes markdown headings and table scaffolding while preserving the factual lead', () => {
+        expect((0, ragPublicText_1.naturalizeRagPublicEvidenceClause)('### Technical specifications The glass density is about 2500 kg/m³. | Parameter | Value | | :--- | :--- | | density | 2500 |')).toBe('Technical specifications The glass density is about 2500 kg/m³.');
+    });
+    test('rejects authoring instructions and evidence-control prose in Chinese and English', () => {
+        expect((0, ragPublicText_1.shouldRejectPublicEvidenceClause)('所有推理过程以英文进行，最终输出为简体中文。')).toBe(true);
+        expect((0, ragPublicText_1.shouldRejectPublicEvidenceClause)('Operators must resolve the active owner before publishing.')).toBe(true);
+        expect((0, ragPublicText_1.shouldRejectPublicEvidenceClause)('The glass wall conducts heat into the environment.')).toBe(false);
+        expect((0, ragPublicText_1.shouldRejectPublicEvidenceClause)('This clause is intentionally beyond the public definition budget and should remain internal.')).toBe(true);
+        expect((0, ragPublicText_1.shouldRejectPublicEvidenceClause)('The response budget limits serialized bytes.')).toBe(false);
+    });
+    test('removes fenced diagram payloads instead of exposing renderer source', () => {
+        expect((0, ragPublicText_1.naturalizeRagPublicEvidenceClause)('Heat moves by conduction and convection. ```mermaid graph TD A --> B ```')).toBe('Heat moves by conduction and convection.');
+    });
+    test('rejects flattened table introductions after Markdown extraction', () => {
+        expect((0, ragPublicText_1.shouldRejectPublicEvidenceClause)('下表列出了标准温度和压力下的典型技术参数。参数 Parameter 密度 2500 999.8 kg/m³ 单位 Unit。')).toBe(true);
+        expect((0, ragPublicText_1.shouldRejectPublicEvidenceClause)('The following table lists typical parameters. Parameter Density Value Unit.')).toBe(true);
+        expect((0, ragPublicText_1.shouldRejectPublicEvidenceClause)('参数 (Parameter) 钠钙玻璃 水 单位 (Unit) :--- :--- 密度 2500 999.8 kg/m³。')).toBe(true);
+    });
+    test('removes flattened section labels while retaining their factual sentence', () => {
+        expect((0, ragPublicText_1.naturalizeRagPublicEvidenceClause)('核心概念及其数学基础：水杯系统通过传导、对流和辐射与环境交换热量。')).toBe('水杯系统通过传导、对流和辐射与环境交换热量。');
+        expect((0, ragPublicText_1.naturalizeRagPublicEvidenceClause)('Material science: Glass is an amorphous solid without long-range order.')).toBe('Glass is an amorphous solid without long-range order.');
+        expect((0, ragPublicText_1.naturalizeRagPublicEvidenceClause)('核心概念及其数学基础 水杯系统通过传导、对流和辐射与环境交换热量。')).toBe('水杯系统通过传导、对流和辐射与环境交换热量。');
+    });
+});

package/dist/src/learning/ragSufficiencyJudge.js

@@ -27,6 +27,10 @@ function hasGraphEvidence(fragments) {
 function hasConflictEvidence(fragments) {
     return fragments.some((fragment) => fragment.role === 'conflict' && textHasSubstance(fragment));
 }
+function hasIncompleteSourceScan(pack) {
+    return pack.sourceDecisions.some(decision => decision.status === 'source_window_unavailable'
+        && String(decision.reason || '').startsWith('runtime_'));
+}
 function hasUnavailableGraphNeighborSourceWindow(pack) {
     return pack.sourceDecisions.some((decision) => (decision.status === 'source_window_unavailable'
         && String(decision.reason || '').includes('graph_neighbor_support')));
@@ -61,6 +65,9 @@ function buildDeterministicReview(params) {
     if (budgetViolation) {
         reasons.push('context_budget_dropped_fragments');
     }
+    const incompleteSourceScan = hasIncompleteSourceScan(params.contextPack);
+    if (incompleteSourceScan)
+        reasons.push('source_scan_incomplete');
     if (!directSupport) {
         return {
             reviewedAt: String(params.reviewedAt || new Date().toISOString()),
@@ -91,6 +98,7 @@ function buildDeterministicReview(params) {
         && documentAugmentation
         && !conflictEvidence
         && !graphNeighborEvidenceMissing
+        && !incompleteSourceScan
         ? 'sufficient'
         : 'borderline';
     return {
@@ -137,11 +145,13 @@ async function reviewRagContextSufficiency(params) {
     const deterministicReview = buildDeterministicReview(params);
     if (deterministicReview.status !== 'borderline'
         || params.allowLlmJudge !== true
-        || typeof params.llmJudge !== 'function') {
+        || typeof params.llmJudge !== 'function'
+        || hasIncompleteSourceScan(params.contextPack)) {
         return deterministicReview;
     }
     try {
         const judgeReview = await params.llmJudge({
+            signal: params.signal,
             query: params.query,
             contextPack: params.contextPack,
             graphContext: params.graphContext,

package/dist/src/learning/ragSufficiencyProviderJudge.js

@@ -155,43 +155,30 @@ function buildReviewContent(input) {
     });
 }
 async function completeWithTimeout(params) {
+    params.request.signal?.throwIfAborted();
     const controller = new AbortController();
     let didTimeout = false;
-    let timer = null;
-    const timeoutPromise = new Promise((_resolve, reject) => {
-        timer = setTimeout(() => {
-            didTimeout = true;
-            controller.abort();
-            reject(new Error('RAG sufficiency judge timed out.'));
-        }, params.timeoutMs);
-        params.request.signal?.addEventListener('abort', () => {
-            if (timer) {
-                clearTimeout(timer);
-                timer = null;
-            }
-            controller.abort();
-            reject(new Error('RAG sufficiency judge cancelled.'));
-        }, { once: true });
-    });
+    const timer = setTimeout(() => {
+        didTimeout = true;
+        controller.abort(new Error('RAG sufficiency judge timed out.'));
+    }, params.timeoutMs);
+    const onParentAbort = () => controller.abort(params.request.signal?.reason);
+    params.request.signal?.addEventListener('abort', onParentAbort, { once: true });
     try {
-        return await Promise.race([
-            params.client.complete({
-                ...params.request,
-                signal: controller.signal,
-            }),
-            timeoutPromise,
-        ]);
+        const completion = await params.client.complete({ ...params.request, signal: controller.signal });
+        controller.signal.throwIfAborted();
+        return completion;
     }
     catch (error) {
         if (didTimeout) {
             throw new Error('RAG sufficiency judge timed out.');
         }
+        params.request.signal?.throwIfAborted();
         throw error;
     }
     finally {
-        if (timer) {
-            clearTimeout(timer);
-        }
+        clearTimeout(timer);
+        params.request.signal?.removeEventListener('abort', onParentAbort);
     }
 }
 function createRagSufficiencyProviderJudge(options) {
@@ -199,7 +186,9 @@ function createRagSufficiencyProviderJudge(options) {
     const timeoutMs = resolveBoundedInteger(options.timeoutMs, DEFAULT_TIMEOUT_MS, MIN_TIMEOUT_MS, MAX_TIMEOUT_MS);
     const maxTokens = resolveBoundedInteger(options.maxTokens, DEFAULT_MAX_TOKENS, MIN_MAX_TOKENS, MAX_MAX_TOKENS);
     return async (input) => {
+        input.signal?.throwIfAborted();
         const settings = await options.settingsProvider();
+        input.signal?.throwIfAborted();
         const provider = (0, LlmProvider_1.selectProviderForTask)(settings, RAG_SUFFICIENCY_TASK_KEY);
         const model = (0, LlmProvider_1.selectModelForTask)(settings, RAG_SUFFICIENCY_TASK_KEY, provider);
         const configuredPrompt = settings.enableGlobalCustomPrompts
@@ -209,6 +198,7 @@ function createRagSufficiencyProviderJudge(options) {
             client,
             timeoutMs,
             request: {
+                signal: input.signal,
                 provider,
                 model,
                 prompt: configuredPrompt || DEFAULT_REVIEW_PROMPT,

package/dist/src/learning/ragSufficiencyProviderJudge.test.js

@@ -1,6 +1,7 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 const ragSufficiencyProviderJudge_1 = require("./ragSufficiencyProviderJudge");
+const events_1 = require("events");
 function makeSettings() {
     return {
         providers: [
@@ -68,6 +69,56 @@ function makePack() {
     };
 }
 describe('createRagSufficiencyProviderJudge', () => {
+    test('turn cancellation reaches provider I/O', async () => {
+        const controller = new AbortController();
+        const reason = new Error('turn_cancelled');
+        let entered;
+        const started = new Promise(resolve => { entered = resolve; });
+        const complete = jest.fn(request => new Promise((_resolve, reject) => {
+            request.signal.addEventListener('abort', () => reject(request.signal.reason), { once: true });
+            entered();
+        }));
+        const judge = (0, ragSufficiencyProviderJudge_1.createRagSufficiencyProviderJudge)({ settingsProvider: makeSettings, llmClient: { complete } });
+        const pending = judge({ query: 'water glass', contextPack: makePack(), signal: controller.signal }).catch(error => error);
+        await started;
+        controller.abort(reason);
+        expect(await pending).toBe(reason);
+        expect(complete.mock.calls[0][0].signal.aborted).toBe(true);
+    });
+    test('does not return while a cancelled provider callback can still run', async () => {
+        const controller = new AbortController();
+        const reason = new Error('turn_cancelled');
+        let release;
+        let entered;
+        const started = new Promise(resolve => { entered = resolve; });
+        const held = new Promise(resolve => { release = resolve; });
+        const complete = jest.fn(async () => { entered(); await held; return { text: '{"status":"sufficient","score":1}', provider: 'OpenAI', model: 'gpt-test' }; });
+        const judge = (0, ragSufficiencyProviderJudge_1.createRagSufficiencyProviderJudge)({ settingsProvider: makeSettings, llmClient: { complete } });
+        let finished = false;
+        const pending = judge({ query: 'water glass', contextPack: makePack(), signal: controller.signal }).catch(error => error).finally(() => { finished = true; });
+        await started;
+        controller.abort(reason);
+        await new Promise(resolve => setImmediate(resolve));
+        const finishedBeforeProviderStopped = finished;
+        release();
+        expect(await pending).toBe(reason);
+        expect(finishedBeforeProviderStopped).toBe(false);
+    });
+    test('a pre-cancelled turn does not start a provider request', async () => {
+        const controller = new AbortController();
+        controller.abort(new Error('already_cancelled'));
+        const complete = jest.fn();
+        const judge = (0, ragSufficiencyProviderJudge_1.createRagSufficiencyProviderJudge)({ settingsProvider: makeSettings, llmClient: { complete } });
+        await expect(judge({ query: 'water glass', contextPack: makePack(), signal: controller.signal })).rejects.toThrow('already_cancelled');
+        expect(complete).not.toHaveBeenCalled();
+    });
+    test('completed provider work releases the parent cancellation listener', async () => {
+        const controller = new AbortController();
+        const complete = jest.fn().mockResolvedValue({ text: '{"status":"sufficient","score":1}', provider: 'OpenAI', model: 'gpt-test' });
+        const judge = (0, ragSufficiencyProviderJudge_1.createRagSufficiencyProviderJudge)({ settingsProvider: makeSettings, llmClient: { complete } });
+        await judge({ query: 'water glass', contextPack: makePack(), signal: controller.signal });
+        expect((0, events_1.getEventListeners)(controller.signal, 'abort')).toHaveLength(0);
+    });
     test('calls the configured NoteMD provider with bounded JSON-only review input', async () => {
         const complete = jest.fn().mockResolvedValue({
             text: '```json\n{"status":"sufficient","score":0.84,"reasons":["answerable_from_context"],"degradationState":"none"}\n```',

package/dist/src/learning/requestNormalization.js

@@ -26,6 +26,92 @@ function parsePositiveIntegerValue(value) {
     }
     return Math.floor(numeric);
 }
+function normalizeAnswerLanguageValue(value) {
+    const normalized = String(value || '')
+        .trim()
+        .toLowerCase()
+        .replace(/_/gu, '-');
+    if (!normalized) {
+        return undefined;
+    }
+    if (normalized === 'auto') {
+        return 'auto';
+    }
+    if (normalized === 'zh'
+        || normalized.startsWith('zh-')
+        || ['chinese', 'mandarin', 'simplified-chinese', 'traditional-chinese'].includes(normalized)) {
+        return 'zh';
+    }
+    if (normalized === 'en'
+        || normalized.startsWith('en-')
+        || normalized === 'english') {
+        return 'en';
+    }
+    return undefined;
+}
+function normalizeResponseProfileValue(value) {
+    const normalized = String(value || '').trim().toLowerCase().replace(/[-\s]+/gu, '_');
+    if (normalized === 'default') {
+        return 'default';
+    }
+    if (normalized === 'mobile_compact' || normalized === 'mobile') {
+        return 'mobile_compact';
+    }
+    return undefined;
+}
+function normalizeResponseModeValue(value) {
+    const normalized = String(value || '').trim().toLowerCase().replace(/[-\s]+/gu, '_');
+    if (normalized === 'slim' || normalized === 'definition' || normalized === 'compact' || normalized === 'default') {
+        return 'slim';
+    }
+    if (normalized === 'full' || normalized === 'comprehensive' || normalized === 'report') {
+        return 'full';
+    }
+    return undefined;
+}
+function normalizeResponseBudgetModeValue(value) {
+    const normalized = String(value || '').trim().toLowerCase().replace(/[-\s]+/gu, '_');
+    if (!normalized || ['adaptive', 'default', 'standard', 'auto'].includes(normalized)) {
+        return 'adaptive';
+    }
+    if (['unbounded', 'no_cap', 'nocap', 'no_limit', 'nolimit', 'unlimited'].includes(normalized)) {
+        return 'unbounded';
+    }
+    return 'adaptive';
+}
+function normalizeResponseBudgetCapabilityValue(value) {
+    if (!isObjectRecord(value)) {
+        return undefined;
+    }
+    const memoryClass = String(value.memoryClass || value.memory_class || '')
+        .trim()
+        .toLowerCase()
+        .replace(/[-\s]+/gu, '_');
+    const workload = String(value.workload || value.workload_class || '')
+        .trim()
+        .toLowerCase()
+        .replace(/[-\s]+/gu, '_');
+    const normalizePositiveHint = (hint) => {
+        const numeric = Number(hint);
+        return Number.isFinite(numeric) && numeric > 0 ? Math.floor(numeric) : undefined;
+    };
+    const normalized = {};
+    if (['low', 'standard', 'high'].includes(memoryClass)) {
+        normalized.memoryClass = memoryClass;
+    }
+    if (['normal', 'large', 'max'].includes(workload)) {
+        normalized.workload = workload;
+    }
+    const maxReportCharsHint = normalizePositiveHint(value.maxReportCharsHint ?? value.max_report_chars_hint);
+    if (maxReportCharsHint !== undefined) {
+        normalized.maxReportCharsHint = maxReportCharsHint;
+    }
+    const maxSerializedBytesHint = normalizePositiveHint(value.maxSerializedBytesHint ?? value.max_serialized_bytes_hint);
+    if (maxSerializedBytesHint !== undefined) {
+        normalized.maxSerializedBytesHint = maxSerializedBytesHint;
+    }
+    return Object.keys(normalized).length > 0 ? normalized : undefined;
+}
 function normalizeStringList(values, options = {}) {
     const list = Array.isArray(values) ? values : [];
     const normalized = list
@@ -81,11 +167,31 @@ function normalizeKnowledgeQueryRequestPayload(payload) {
 function normalizeAgentConversationRequestPayload(payload) {
     const record = isObjectRecord(payload) ? payload : {};
     const topKValue = parsePositiveIntegerValue(readFirstPresentValue(record, ['topK', 'k', 'limit']));
+    const answerLanguage = normalizeAnswerLanguageValue(readFirstPresentValue(record, ['answerLanguage', 'answer_language', 'responseLanguage', 'response_language']));
+    const responseProfile = normalizeResponseProfileValue(readFirstPresentValue(record, ['responseProfile', 'response_profile', 'profile']));
+    const responseMode = normalizeResponseModeValue(readFirstPresentValue(record, ['responseMode', 'response_mode', 'answerMode', 'answer_mode', 'detailMode', 'detail_mode']));
+    const responseBudgetMode = normalizeResponseBudgetModeValue(readFirstPresentValue(record, [
+        'responseBudgetMode',
+        'response_budget_mode',
+        'budgetMode',
+        'budget_mode',
+    ]));
+    const responseBudgetCapability = normalizeResponseBudgetCapabilityValue(readFirstPresentValue(record, [
+        'responseBudgetCapability',
+        'response_budget_capability',
+        'budgetCapability',
+        'budget_capability',
+    ]));
     return {
         userId: String(readFirstPresentValue(record, ['userId', 'user_id', 'learnerId']) || '').trim(),
         sessionId: readFirstNonEmptyString(record, ['sessionId', 'session_id']),
         activeTarget: readFirstNonEmptyString(record, ['activeTarget', 'active_target', 'target']),
         message: readFirstNonEmptyString(record, ['message', 'prompt', 'query', 'q', 'text']) || '',
+        answerLanguage,
+        responseMode,
+        responseBudgetMode,
+        responseBudgetCapability,
+        responseProfile,
         topK: topKValue > 0 ? topKValue : undefined,
         asOf: readFirstNonEmptyString(record, ['asOf', 'as_of', 'timestamp', 'now']),
         persistMemory: readFirstPresentValue(record, ['persistMemory', 'persist_memory']) !== false,

package/dist/src/learning/requestNormalization.test.js

@@ -0,0 +1,101 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const requestNormalization_1 = require("./requestNormalization");
+describe('agent conversation request normalization', () => {
+    test.each([
+        ['zh-CN', 'zh'],
+        ['zh_CN', 'zh'],
+        ['Chinese', 'zh'],
+        ['en-US', 'en'],
+        ['en_US', 'en'],
+        ['English', 'en'],
+        ['auto', 'auto'],
+        ['unsupported-language', undefined],
+    ])('normalizes answer language %s to %s', (answerLanguage, expectedLanguage) => {
+        expect((0, requestNormalization_1.normalizeAgentConversationRequestPayload)({
+            message: 'what is water glass?',
+            answerLanguage,
+        }).answerLanguage).toBe(expectedLanguage);
+    });
+    test('keeps an explicit English answer contract even when the query contains CJK text', () => {
+        expect((0, requestNormalization_1.normalizeAgentConversationRequestPayload)({
+            message: '\u4ec0\u4e48\u662f water glass?',
+            response_language: 'en-US',
+        }).answerLanguage).toBe('en');
+    });
+    test('normalizes the additive mobile response profile without changing the default', () => {
+        expect((0, requestNormalization_1.normalizeAgentConversationRequestPayload)({
+            message: 'what is water glass?',
+            response_profile: 'mobile',
+        }).responseProfile).toBe('mobile_compact');
+        expect((0, requestNormalization_1.normalizeAgentConversationRequestPayload)({
+            message: 'what is water glass?',
+        }).responseProfile).toBeUndefined();
+    });
+    test.each([
+        [undefined, undefined],
+        ['slim', 'slim'],
+        ['definition', 'slim'],
+        ['compact', 'slim'],
+        ['full', 'full'],
+        ['comprehensive', 'full'],
+        ['unsupported-mode', undefined],
+    ])('normalizes answer response mode %s to %s', (responseMode, expectedMode) => {
+        expect((0, requestNormalization_1.normalizeAgentConversationRequestPayload)({
+            message: 'what is water glass?',
+            responseMode,
+        }).responseMode).toBe(expectedMode);
+    });
+    test('keeps response mode independent from the mobile response profile', () => {
+        const request = (0, requestNormalization_1.normalizeAgentConversationRequestPayload)({
+            message: 'what is water glass?',
+            response_mode: 'full',
+            response_profile: 'mobile',
+        });
+        expect(request.responseMode).toBe('full');
+        expect(request.responseProfile).toBe('mobile_compact');
+    });
+    test.each([
+        [undefined, 'adaptive'],
+        ['adaptive', 'adaptive'],
+        ['unbounded', 'unbounded'],
+        ['no-cap', 'unbounded'],
+        ['no_cap', 'unbounded'],
+        ['unsupported-budget', 'adaptive'],
+    ])('normalizes response budget mode %s to %s', (responseBudgetMode, expectedMode) => {
+        expect((0, requestNormalization_1.normalizeAgentConversationRequestPayload)({
+            message: 'what is water glass?',
+            responseBudgetMode,
+        }).responseBudgetMode).toBe(expectedMode);
+    });
+    test('normalizes and clamps response budget capability hints at the boundary', () => {
+        const request = (0, requestNormalization_1.normalizeAgentConversationRequestPayload)({
+            message: 'what is water glass?',
+            response_budget_mode: 'unbounded',
+            response_budget_capability: {
+                memoryClass: 'HIGH',
+                workload: 'max',
+                maxReportCharsHint: 999999999,
+                maxSerializedBytesHint: -4,
+                ignored: 'field',
+            },
+        });
+        expect(request.responseBudgetMode).toBe('unbounded');
+        expect(request.responseBudgetCapability).toEqual({
+            memoryClass: 'high',
+            workload: 'max',
+            maxReportCharsHint: 999999999,
+        });
+    });
+    test('keeps budget mode additive when mobile projection is requested', () => {
+        const request = (0, requestNormalization_1.normalizeAgentConversationRequestPayload)({
+            message: 'what is water glass?',
+            response_mode: 'full',
+            response_budget_mode: 'unbounded',
+            response_profile: 'mobile',
+        });
+        expect(request.responseMode).toBe('full');
+        expect(request.responseBudgetMode).toBe('unbounded');
+        expect(request.responseProfile).toBe('mobile_compact');
+    });
+});