diff --git a/packages/core-test-kit/README.md b/packages/core-test-kit/README.md
index b2b10bd8b..e56e4d911 100644
--- a/packages/core-test-kit/README.md
+++ b/packages/core-test-kit/README.md
@@ -2,117 +2,126 @@
 
 [![npm version](https://img.shields.io/npm/v/@stylable/core-test-kit.svg)](https://www.npmjs.com/package/stylable/core-test-kit)
 
-`@stylable/core-test-kit` is a collection of utilities aimed at making testing Stylable core behavior and functionality easier.
+## Inline expectations syntax
 
-## What's in this test-kit?
+The inline expectation syntax can be used with `testInlineExpects` for testing stylesheets transformation and diagnostics.
 
-### Matchers
+An expectation is written as a comment just before the code it checks on. All expectations support `label` that will be thrown as part of an expectation fail message.
 
-An assortment of `Chai` matchers used by Stylable.
+### `@rule` - check rule transformation including selector and nested declarations:
 
-- `flat-match` - flattens and matches passed arguments
-- `results` - test Stylable transpiled style rules output
-
-### Diagnostics tooling
-
-A collection of tools used for testing Stylable diagnostics messages (warnings and errors).
-
-- `expectAnalyzeDiagnostics` - processes a Stylable input and checks for diagnostics during processing
-- `expectTransformDiagnostics` - checks for diagnostics after a full transformation
-- `shouldReportNoDiagnostics` - helper to check no diagnostics were reported
-
-### Testing infrastructure
-
-Used for setting up Stylable instances (`processor`/`transformer`) and their infrastructure:
+Selector - `@rule SELECTOR`
+```css 
+/* @rule .entry__root::before */
+.root::before {}
+```
 
-- `generateInfra` - create Stylable basic in memory infrastructure (`resolver`, `requireModule`, `fileProcessor`)
-- `generateStylableResult` - genetare transformation results from in memory configuration
-- `generateStylableRoot` - helper over `generateStylableResult` that returns the `outputAst`
-- `generateStylableExports` - helper over `generateStylableResult` that returns the `exports` mapping
+Declarations - `@rule SELECTOR { decl: val; }`
+```css 
+/* @rule .entry__root { color: red } */
+.root { color: red; }
 
-### `testInlineExpects` utility
+/* @rule .entry__root {
+    color: red;
+    background: green;
+}*/
+.root {
+    color: red;
+    background: green;
+}
+```
 
-Exposes `testInlineExpects` for testing transformed stylesheets that include inline expectation comments. These are the most common type of core tests and the recommended way of testing the core functionality.
+Target generated rules (mixin) - ` @rule[OFFSET] SELECTOR`
+```css
+.mix {
+    color: red;
+}
+.mix:hover {
+    color: green;
+}
+/* 
+    @rule .entry__root {color: red;} 
+    @rule[1] .entry__root:hover {color: green;} 
+*/
+.root {
+    -st-mixin: mix;
+}
+```
 
-#### Supported checks:
+Label - `@rule(LABEL) SELECTOR`
+```css
+/* @rule(expect 1) .entry__root */
+.root {}
 
-Rule checking (place just before rule) supporting multi-line declarations and multiple `@checks` statements
+/* @rule(expect 2) .entry__part */
+.part {}
+```
 
-##### Terminilogy
-- `LABEL: <string>` - label for the test expectation 
-- `OFFEST: <number>` - offest for the tested rule after the `@check`   
-- `SELECTOR: <string>` - output selector
-- `DECL: <string>` - declaration name
-- `VALUE: <string>` - declaration value 
+### `@atrule` - check at-rule transformation of params:
 
-Full options:
+AtRule params - `@atrule PARAMS`:
 ```css
-/* @check(LABEL)[OFFEST] SELECTOR {DECL: VALUE} */
+/* @atrule screen and (min-width: 900px) */
+@media value(smallScreen) {}
 ```
 
-Basic - `@check SELECTOR`
-```css 
-/* @check header::before */
-header::before {}
+Label - `@atrule(LABEL) PARAMS`
+```css
+/* @atrule(jump keyframes) entry__jump */
+@keyframes jump {}
 ```
 
-With declarations - ` @check SELECTOR {DECL1: VALUE1; DECL2: VALUE2;}`
+### `@decl` - check declaration transformation
 
-This will check full match and order.
-```css 
-.my-mixin {
-    color: red;
+Prop & value - `@decl PROP: VALUE`
+```css
+.root {
+    /* @decl color: red */
+    color: red
 }
+```
 
-/* @check .entry__container {color: red;} */
-.container {
-    -st-mixin: my-mixin;
+Label - `@decl(LABEL) PROP: VALUE`
+```css
+.root {
+    /* @decl(color is red) color: red */
+    color: red;
 }
 ```
 
-Target generated rules (mixin) - ` @check[OFFEST] SELECTOR`
+### `@analyze` & `@transform` - check single file (analyze) and multiple files (transform) diagnostics:
+
+Severity - `@analyze-SEVERITY MESSAGE` / `@transform-SEVERITY MESSAGE`
 ```css
-.my-mixin {
-    color: blue;
-}
-/* 
-    @check[1] .entry__container:hover {color: blue;} 
-*/
-.container {
-    -st-mixin: my-mixin;
+/* @analyze-info found deprecated usage */
+@st-global-custom-property --x;
+
+/* @analyze-warn missing keyframes name */
+@keyframes {}
+
+/* @analyze-error invalid functional id */
+#id() {}
+
+.root {
+    /* @transform-error unresolved "unknown" build variable */
+    color: value(unknown);
 }
 ```
 
-Support atrule params (anything between the @atrule and body or semicolon):
+Word - `@analyze-SEVERITY word(TEXT) MESSAGE` / `@transform-SEVERITY word(TEXT) MESSAGE`
 ```css
-/* @check screen and (min-width: 900px) */
-@media value(smallScreen) {}
-```
-#### Example 
-Here we are generating a Stylable AST which lncludes the `/* @check SELECTOR */` comment to test the root class selector target.
-
-The `testInlineExpects` function performs that actual assertions to perform the test.
-
-```ts
-it('...', ()=>{
-    const root = generateStylableRoot({
-        entry: `/style.st.css`,
-        files: {
-            '/style.st.css': {
-                namespace: 'ns',
-                content: `
-                /* @check .ns__root */
-                .root {}
-            `
-        },
-    });
-    testInlineExpects(root, 1);
-})
+/* @transform-warn word(unknown) unknown pseudo element */
+.root::unknown {}
 ```
 
-### Match rules
+Label - `@analyze(LABEL) MESSAGE` / `@transform(LABEL) MESSAGE`
+```css
+/* @analyze-warn(local keyframes) missing keyframes name */
+@keyframes {}
 
-Exposes two utility functions (`matchRuleAndDeclaration` and `matchAllRulesAndDeclarations`) used for testing Stylable generated AST representing CSS rules and declarations.
+/* @transform-warn(imported keyframes) unresolved keyframes "unknown" */
+@keyframes unknown {}
+```
 
 ## License
 
diff --git a/packages/core-test-kit/src/diagnostics.ts b/packages/core-test-kit/src/diagnostics.ts
index 492f83f3c..8cf7d95c6 100644
--- a/packages/core-test-kit/src/diagnostics.ts
+++ b/packages/core-test-kit/src/diagnostics.ts
@@ -26,6 +26,117 @@ export interface Location {
     css: string;
 }
 
+interface MatchState {
+    matches: number;
+    location: string;
+    word: string;
+    severity: string;
+}
+const createMatchDiagnosticState = (): MatchState => ({
+    matches: 0,
+    location: ``,
+    word: ``,
+    severity: ``,
+});
+const isSupportedSeverity = (val: string): val is DiagnosticType => !!val.match(/info|warn|error/);
+export function matchDiagnostic(
+    type: `analyze` | `transform`,
+    meta: Pick<StylableMeta, `diagnostics` | `transformDiagnostics`>,
+    expected: {
+        label?: string;
+        message: string;
+        severity: string;
+        location: Location;
+    },
+    errors: {
+        diagnosticsNotFound: (type: string, message: string, label?: string) => string;
+        unsupportedSeverity: (type: string, severity: string, label?: string) => string;
+        locationMismatch: (type: string, message: string, label?: string) => string;
+        wordMismatch: (
+            type: string,
+            expectedWord: string,
+            message: string,
+            label?: string
+        ) => string;
+        severityMismatch: (
+            type: string,
+            expectedSeverity: string,
+            actualSeverity: string,
+            message: string,
+            label?: string
+        ) => string;
+        expectedNotFound: (type: string, message: string, label?: string) => string;
+    }
+): string {
+    const diagnostics = type === `analyze` ? meta.diagnostics : meta.transformDiagnostics;
+    if (!diagnostics) {
+        return errors.diagnosticsNotFound(type, expected.message, expected.label);
+    }
+    const expectedSeverity =
+        (expected.severity as any) === `warn` ? `warning` : expected.severity || ``;
+    if (!isSupportedSeverity(expectedSeverity)) {
+        return errors.unsupportedSeverity(type, expected.severity || ``, expected.label);
+    }
+    let closestMatchState = createMatchDiagnosticState();
+    const foundPartialMatch = (newState: MatchState) => {
+        if (newState.matches >= closestMatchState.matches) {
+            closestMatchState = newState;
+        }
+    };
+    for (const report of diagnostics.reports.values()) {
+        const matchState = createMatchDiagnosticState();
+        if (report.message !== expected.message) {
+            foundPartialMatch(matchState);
+            continue;
+        }
+        matchState.matches++;
+        // if (!expected.skipLocationCheck) {
+        // ToDo: test all range
+        if (report.node.source!.start!.offset !== expected.location.start!.offset) {
+            matchState.location = errors.locationMismatch(type, expected.message, expected.label);
+            foundPartialMatch(matchState);
+            continue;
+        }
+        matchState.matches++;
+        // }
+        if (expected.location.word) {
+            if (report.options.word !== expected.location.word) {
+                matchState.word = errors.wordMismatch(
+                    type,
+                    expected.location.word,
+                    expected.message,
+                    expected.label
+                );
+                foundPartialMatch(matchState);
+                continue;
+            }
+            matchState.matches++;
+        }
+        if (expected.severity) {
+            if (report.type !== expectedSeverity) {
+                matchState.location = errors.severityMismatch(
+                    type,
+                    expectedSeverity,
+                    report.type,
+                    expected.message,
+                    expected.label
+                );
+                foundPartialMatch(matchState);
+                continue;
+            }
+            matchState.matches++;
+        }
+        // expected matched!
+        return ``;
+    }
+    return (
+        closestMatchState.location ||
+        closestMatchState.word ||
+        closestMatchState.severity ||
+        errors.expectedNotFound(type, expected.message, expected.label)
+    );
+}
+
 export function findTestLocations(css: string) {
     let line = 1;
     let column = 1;
diff --git a/packages/core-test-kit/src/inline-expectation.ts b/packages/core-test-kit/src/inline-expectation.ts
index 820b3dd9a..5026bc897 100644
--- a/packages/core-test-kit/src/inline-expectation.ts
+++ b/packages/core-test-kit/src/inline-expectation.ts
@@ -1,19 +1,31 @@
+import { matchDiagnostic } from './diagnostics';
+import type { StylableMeta } from '@stylable/core';
 import type * as postcss from 'postcss';
 
-interface RuleCheck {
-    kind: `rule`;
-    rule: postcss.Rule;
-    msg?: string;
-    expectedSelector: string;
-    expectedDeclarations: [string, string][];
-    declarationCheck: 'full' | 'none';
+interface Test {
+    type: TestScopes;
+    expectation: string;
+    errors: string[];
 }
-interface AtRuleCheck {
-    kind: `atrule`;
-    rule: postcss.AtRule;
-    msg?: string;
-    expectedParams: string;
+
+type AST = postcss.Rule | postcss.AtRule | postcss.Declaration;
+
+const tests = {
+    '@check': checkTest,
+    '@rule': ruleTest,
+    '@atrule': atRuleTest,
+    '@decl': declTest,
+    '@analyze': analyzeTest,
+    '@transform': transformTest,
+} as const;
+type TestScopes = keyof typeof tests;
+const testScopes = Object.keys(tests) as TestScopes[];
+const testScopesRegex = () => testScopes.join(`|`);
+
+interface Context {
+    meta: Pick<StylableMeta, 'outputAst' | 'rawAst' | 'diagnostics' | 'transformDiagnostics'>;
 }
+const isRoot = (val: any): val is postcss.Root => val.type === `root`;
 
 /**
  * Test transformed stylesheets inline expectation comments
@@ -47,161 +59,385 @@ interface AtRuleCheck {
  * support atrule params (anything between the @atrule and body or semicolon)
  * @check screen and (min-width: 900px)
  */
-export function testInlineExpects(
-    result: postcss.Root,
-    expectedTestsCount = result.toString().match(/@check/gm)!.length
-) {
-    if (expectedTestsCount === 0) {
-        throw new Error('no tests found try to add @check comments before any selector');
-    }
-    const checks: Array<RuleCheck | AtRuleCheck> = [];
+export function testInlineExpects(result: postcss.Root | Context, expectedTestInput?: number) {
+    // backward compatibility (no diagnostic checks)
+    const isDeprecatedInput = isRoot(result);
+    const context = isDeprecatedInput
+        ? {
+              meta: {
+                  outputAst: result,
+                  rawAst: null as unknown as StylableMeta['rawAst'],
+                  diagnostics: null as unknown as StylableMeta['diagnostics'],
+                  transformDiagnostics: null as unknown as StylableMeta['transformDiagnostics'],
+              },
+          }
+        : result;
+    // ToDo: support analyze mode
+    const rootAst = context.meta.outputAst!;
+    const expectedTestAmount =
+        expectedTestInput ??
+        (rootAst.toString().match(new RegExp(`${testScopesRegex()}`, `gm`))?.length || 0);
+    const checks: Test[] = [];
     const errors: string[] = [];
-
     // collect checks
-    result.walkComments((comment) => {
-        const checksInput = comment.text.split(`@check`);
-        const rule = comment.next();
-        if (checksInput.length > 1 && rule) {
-            if (rule.type === `rule`) {
-                for (const checkInput of checksInput) {
-                    if (checkInput.trim()) {
-                        const check = createRuleCheck(rule, checkInput, errors);
-                        if (check) {
-                            checks.push(check);
+    rootAst.walkComments((comment) => {
+        const input = comment.text.split(/@/gm);
+        const testCommentTarget = comment;
+        const testCommentSrc = isDeprecatedInput
+            ? comment
+            : getSourceComment(context.meta, comment) || comment;
+        const nodeTarget = testCommentTarget.next() as AST;
+        const nodeSrc = testCommentSrc.next() as AST;
+        if (nodeTarget || nodeSrc) {
+            while (input.length) {
+                const next = `@` + input.shift()!;
+                const testMatch = next.match(new RegExp(`^(${testScopesRegex()})`, `g`));
+                if (testMatch) {
+                    const testScope = testMatch[0] as TestScopes;
+                    let testInput = next.replace(testScope, ``);
+                    // collect expectation inner `@` fragments
+                    while (
+                        input.length &&
+                        !(`@` + input[0]).match(new RegExp(`^(${testScopesRegex()})`, `g`))
+                    ) {
+                        testInput += `@` + input.shift();
+                    }
+                    if (testInput) {
+                        if (
+                            isDeprecatedInput &&
+                            (testScope === `@analyze` || testScope === `@transform`)
+                        ) {
+                            // not possible with just AST root
+                            const result: Test = {
+                                type: testScope,
+                                expectation: testInput.trim(),
+                                errors: [
+                                    testInlineExpectsErrors.deprecatedRootInputNotSupported(
+                                        testScope + testInput
+                                    ),
+                                ],
+                            };
+                            errors.push(...result.errors);
+                            checks.push(result);
+                        } else {
+                            const result = tests[testScope](
+                                context,
+                                testInput.trim(),
+                                nodeTarget,
+                                nodeSrc
+                            );
+                            result.type = testScope;
+                            errors.push(...result.errors);
+                            checks.push(result);
                         }
                     }
                 }
             }
-            if (rule.type === `atrule`) {
-                if (checksInput.length > 2) {
-                    errors.push(testInlineExpectsErrors.atRuleMultiTest(comment.text));
-                }
-                const check = createAtRuleCheck(rule, checksInput[1]);
-                if (check) {
-                    checks.push(check);
-                }
-            }
-        }
-    });
-    // check
-    checks.forEach((check) => {
-        if (check.kind === `rule`) {
-            const { msg, rule, expectedSelector, expectedDeclarations, declarationCheck } = check;
-            const prefix = msg ? msg + `: ` : ``;
-            if (rule.selector !== expectedSelector) {
-                errors.push(
-                    testInlineExpectsErrors.selector(expectedSelector, rule.selector, prefix)
-                );
-            }
-            if (declarationCheck === `full`) {
-                const actualDecl = rule.nodes.map((x) => x.toString()).join(`; `);
-                const expectedDecl = expectedDeclarations
-                    .map(([prop, value]) => `${prop}: ${value}`)
-                    .join(`; `);
-                if (actualDecl !== expectedDecl) {
-                    errors.push(
-                        testInlineExpectsErrors.declarations(
-                            expectedDecl,
-                            actualDecl,
-                            rule.selector,
-                            prefix
-                        )
-                    );
-                }
-            }
-        } else if (check.kind === `atrule`) {
-            const { msg, rule, expectedParams } = check;
-            const prefix = msg ? msg + `: ` : ``;
-            if (rule.params !== expectedParams) {
-                errors.push(
-                    testInlineExpectsErrors.atruleParams(expectedParams, rule.params, prefix)
-                );
-            }
         }
     });
     // report errors
     if (errors.length) {
         throw new Error(testInlineExpectsErrors.combine(errors));
     }
-    if (expectedTestsCount !== checks.length) {
-        throw new Error(testInlineExpectsErrors.matchAmount(expectedTestsCount, checks.length));
+    if (expectedTestAmount !== checks.length) {
+        throw new Error(testInlineExpectsErrors.matchAmount(expectedTestAmount, checks.length));
     }
 }
 
-function createRuleCheck(
-    rule: postcss.Rule,
-    expectInput: string,
-    errors: string[]
-): RuleCheck | undefined {
-    const { msg, ruleIndex, expectedSelector, expectedBody } = expectInput.match(
+function checkTest(context: Context, expectation: string, targetNode: AST, srcNode: AST): Test {
+    const type = targetNode?.type;
+    switch (type) {
+        case `rule`: {
+            return tests[`@rule`](context, expectation, targetNode, srcNode);
+        }
+        case `atrule`: {
+            return tests[`@atrule`](context, expectation, targetNode, srcNode);
+        }
+        default:
+            return {
+                type: `@check`,
+                expectation,
+                errors: [testInlineExpectsErrors.unsupportedNode(`@check`, type)],
+            };
+    }
+}
+function ruleTest(context: Context, expectation: string, targetNode: AST, _srcNode: AST): Test {
+    const result: Test = {
+        type: `@rule`,
+        expectation,
+        errors: [],
+    };
+    const { msg, ruleIndex, expectedSelector, expectedBody } = expectation.match(
         /(?<msg>\(.*\))*(\[(?<ruleIndex>\d+)\])*(?<expectedSelector>[^{}]*)\s*(?<expectedBody>.*)/s
     )!.groups!;
-    const targetRule = ruleIndex ? getNextMixinRule(rule, Number(ruleIndex)) : rule;
-    if (!targetRule) {
-        errors.push(testInlineExpectsErrors.unfoundMixin(expectInput));
-        return;
+    let testNode: AST = targetNode;
+    // get mixed-in rule
+    if (ruleIndex) {
+        if (targetNode?.type !== `rule`) {
+            result.errors.push(
+                `mixed-in expectation is only supported for CSS Rule, not ${targetNode?.type}`
+            );
+            return result;
+        } else {
+            const actualTarget = getNextMixinRule(targetNode, Number(ruleIndex));
+            if (!actualTarget) {
+                result.errors.push(testInlineExpectsErrors.unfoundMixin(expectation));
+                return result;
+            }
+            testNode = actualTarget as AST;
+        }
     }
-    const expectedDeclarations: RuleCheck[`expectedDeclarations`] = [];
-    const declsInput = expectedBody.trim().match(/^{(.*)}$/s);
-    const declarationCheck: RuleCheck[`declarationCheck`] = declsInput ? `full` : `none`;
-    if (declsInput && declsInput[1]?.includes(`:`)) {
-        for (const decl of declsInput[1].split(`;`)) {
-            if (decl.trim() !== ``) {
-                const [prop, value] = decl.split(':');
-                if (prop && value) {
-                    expectedDeclarations.push([prop.trim(), value.trim()]);
-                } else {
-                    errors.push(testInlineExpectsErrors.malformedDecl(decl, expectInput));
+    // test by target node type
+    const nodeType = testNode?.type;
+    if (nodeType === `rule`) {
+        const expectedDeclarations: [string, string][] = [];
+        const declsInput = expectedBody.trim().match(/^{(.*)}$/s);
+        const declarationCheck: 'full' | 'none' = declsInput ? `full` : `none`;
+        if (declsInput && declsInput[1]?.includes(`:`)) {
+            for (const decl of declsInput[1].split(`;`)) {
+                if (decl.trim() !== ``) {
+                    const [prop, value] = decl.split(':');
+                    if (prop && value) {
+                        expectedDeclarations.push([prop.trim(), value.trim()]);
+                    } else {
+                        result.errors.push(
+                            testInlineExpectsErrors.ruleMalformedDecl(decl, expectation)
+                        );
+                    }
                 }
             }
         }
+        const prefix = msg ? msg + `: ` : ``;
+        if (testNode.selector !== expectedSelector.trim()) {
+            result.errors.push(
+                testInlineExpectsErrors.selector(expectedSelector.trim(), testNode.selector, prefix)
+            );
+        }
+        if (declarationCheck === `full`) {
+            const actualDecl = testNode.nodes.map((x) => x.toString()).join(`; `);
+            const expectedDecl = expectedDeclarations
+                .map(([prop, value]) => `${prop}: ${value}`)
+                .join(`; `);
+            if (actualDecl !== expectedDecl) {
+                result.errors.push(
+                    testInlineExpectsErrors.declarations(
+                        expectedDecl,
+                        actualDecl,
+                        testNode.selector,
+                        prefix
+                    )
+                );
+            }
+        }
+    } else if (nodeType === `atrule`) {
+        // passing null to srcNode as atruleTest doesn't actually requires it.
+        // if it would at some point, then its just a matter of searching the rawAst for it.
+        return atRuleTest(
+            context,
+            expectation.replace(`[${ruleIndex}]`, ``),
+            testNode,
+            null as unknown as AST
+        );
+    } else {
+        // unsupported mixed-in node test
+        result.errors.push(testInlineExpectsErrors.unsupportedMixinNode(testNode.type));
     }
-    return {
-        kind: `rule`,
-        msg,
-        rule: targetRule,
-        expectedSelector: expectedSelector.trim(),
-        expectedDeclarations,
-        declarationCheck,
-    };
+    return result;
 }
-function createAtRuleCheck(rule: postcss.AtRule, expectInput: string): AtRuleCheck | undefined {
-    const { msg, expectedParams } = expectInput.match(/(?<msg>\([^)]*\))*(?<expectedParams>.*)/)!
+function atRuleTest(_context: Context, expectation: string, targetNode: AST, _srcNode: AST): Test {
+    const result: Test = {
+        type: `@atrule`,
+        expectation,
+        errors: [],
+    };
+    const { msg, expectedParams } = expectation.match(/(?<msg>\([^)]*\))*(?<expectedParams>.*)/)!
         .groups!;
-    return {
-        kind: `atrule`,
-        msg,
-        rule,
-        expectedParams: expectedParams.trim(),
+    if (expectedParams.match(/^\[\d+\]/)) {
+        result.errors.push(testInlineExpectsErrors.atRuleMultiTest(expectation));
+        return result;
+    }
+    const prefix = msg ? msg + `: ` : ``;
+    if (targetNode.type === `atrule`) {
+        if (targetNode.params !== expectedParams.trim()) {
+            result.errors.push(
+                testInlineExpectsErrors.atruleParams(
+                    expectedParams.trim(),
+                    targetNode.params,
+                    prefix
+                )
+            );
+        }
+    } else {
+        result.errors.push(testInlineExpectsErrors.unsupportedNode(`@atrule`, targetNode.type));
+    }
+    return result;
+}
+function declTest(_context: Context, expectation: string, targetNode: AST, _srcNode: AST): Test {
+    const result: Test = {
+        type: `@decl`,
+        expectation,
+        errors: [],
+    };
+    let { label, prop, value } = expectation.match(
+        /(?<label>\([^)]*\))*(?<prop>[^:]*)\s*:?\s*(?<value>.*)/
+    )!.groups!;
+    label = label ? label + `: ` : ``;
+    prop = prop.trim();
+    value = value.trim();
+    if (!prop || !value) {
+        result.errors.push(testInlineExpectsErrors.declMalformed(prop, value, label));
+    } else if (targetNode.type === `decl`) {
+        if (targetNode.prop !== prop.trim() || targetNode.value !== value) {
+            const expected = prop.trim() + `: ` + value.trim();
+            const actual = targetNode.prop + `: ` + targetNode.value;
+            result.errors.push(testInlineExpectsErrors.decl(expected, actual, label));
+        }
+    } else {
+        result.errors.push(
+            testInlineExpectsErrors.unsupportedNode(`@decl`, targetNode.type, label)
+        );
+    }
+    return result;
+}
+function analyzeTest(context: Context, expectation: string, targetNode: AST, srcNode: AST): Test {
+    return diagnosticTest(`analyze`, context, expectation, targetNode, srcNode);
+}
+function transformTest(context: Context, expectation: string, targetNode: AST, srcNode: AST): Test {
+    return diagnosticTest(`transform`, context, expectation, targetNode, srcNode);
+}
+function diagnosticTest(
+    type: `analyze` | `transform`,
+    { meta }: Context,
+    expectation: string,
+    _targetNode: AST,
+    srcNode: AST
+): Test {
+    const result: Test = {
+        type: `@${type}`,
+        expectation,
+        errors: [],
     };
+    const matchResult = expectation.match(
+        /-(?<severity>\w+)(?<label>\([^)]*\))?\s?(?:word\((?<word>[^)]*)\))?\s?(?<message>.*)/
+    );
+    if (!matchResult) {
+        result.errors.push(testInlineExpectsErrors.diagnosticsMalformed(type, expectation));
+        return result;
+    }
+    let { label, severity, message, word } = matchResult.groups!;
+    label = label ? label + `: ` : ``;
+    severity = severity?.trim() || ``;
+    message = message?.trim() || ``;
+    word = word?.trim() || ``;
+
+    if (!message) {
+        result.errors.push(testInlineExpectsErrors.diagnosticsMalformed(type, expectation, label));
+        return result;
+    }
+    // check for diagnostic
+    const error = matchDiagnostic(
+        type,
+        meta,
+        {
+            label,
+            message,
+            severity,
+            location: {
+                start: srcNode.source?.start,
+                end: srcNode.source?.end,
+                word,
+                css: ``,
+            },
+        },
+        {
+            diagnosticsNotFound: testInlineExpectsErrors.diagnosticsNotFound,
+            unsupportedSeverity: testInlineExpectsErrors.diagnosticsUnsupportedSeverity,
+            locationMismatch: testInlineExpectsErrors.diagnosticsLocationMismatch,
+            wordMismatch: testInlineExpectsErrors.diagnosticsWordMismatch,
+            severityMismatch: testInlineExpectsErrors.diagnosticsSeverityMismatch,
+            expectedNotFound: testInlineExpectsErrors.diagnosticExpectedNotFound,
+        }
+    );
+    if (error) {
+        result.errors.push(error);
+    }
+    return result;
+}
+
+function getSourceComment(meta: Context['meta'], { source }: postcss.Comment) {
+    let match: postcss.Comment | undefined = undefined;
+    meta.rawAst.walkComments((srcComment) => {
+        if (
+            srcComment.source?.start?.offset === source?.start?.offset &&
+            srcComment.source?.end?.offset === source?.end?.offset
+        ) {
+            match = srcComment;
+            return false;
+        }
+        return;
+    });
+    return match;
 }
 
-function getNextMixinRule(currentRule: postcss.Rule, count: number): postcss.Rule | undefined {
-    while (currentRule && count > 0) {
-        const next: postcss.ChildNode | undefined = currentRule.next();
-        // next must be a rule sense mixin can only add rules
-        if (next?.type === `rule`) {
-            currentRule = next;
+function getNextMixinRule(originRule: postcss.Rule, count: number) {
+    let current: postcss.Node | undefined = originRule;
+    while (current && count > 0) {
+        current = current.next();
+        if (current?.type !== `comment`) {
             count--;
-        } else {
-            return;
         }
     }
-    return currentRule && count === 0 ? currentRule : undefined;
+    return current && count === 0 ? current : undefined;
 }
 
 export const testInlineExpectsErrors = {
     matchAmount: (expectedAmount: number, actualAmount: number) =>
-        `Expected ${expectedAmount} checks to run but there was ${actualAmount}`,
+        `Expected "${expectedAmount}" checks to run but "${actualAmount}" were found`,
+    unsupportedNode: (testType: string, nodeType: string, label = ``) =>
+        `${label}unsupported type "${testType}" for "${nodeType}"`,
     selector: (expectedSelector: string, actualSelector: string, label = ``) =>
-        `${label}expected ${actualSelector} to transform to ${expectedSelector}`,
+        `${label}expected "${actualSelector}" to transform to "${expectedSelector}"`,
     declarations: (expectedDecl: string, actualDecl: string, selector: string, label = ``) =>
         `${label}expected ${selector} to have declaration {${expectedDecl}}, but got {${actualDecl}}`,
     unfoundMixin: (expectInput: string) => `cannot locate mixed-in rule for "${expectInput}"`,
-    malformedDecl: (decl: string, expectInput: string) =>
+    unsupportedMixinNode: (type: string) => `unsupported mixin expectation of type "${type}"`,
+    ruleMalformedDecl: (decl: string, expectInput: string) =>
         `error in expectation "${decl}" of "${expectInput}"`,
     atruleParams: (expectedParams: string, actualParams: string, label = ``) =>
-        `${label}expected ${actualParams} to transform to ${expectedParams}`,
-    atRuleMultiTest: (comment: string) => `atrule multi test is not supported (${comment})`,
+        `${label}expected "${actualParams}" to transform to ${expectedParams}`,
+    atRuleMultiTest: (comment: string) => `atrule mixin is not supported: (${comment})`,
+    decl: (expected: string, actual: string, label = ``) =>
+        `${label}expected "${actual}" to transform to "${expected}"`,
+    declMalformed: (expectedProp: string, expectedLabel: string, label = ``) => {
+        if (!expectedProp && !expectedLabel) {
+            return `${label}malformed declaration expectation, format should be: "prop: value"`;
+        } else if (!expectedProp) {
+            return `${label}malformed declaration expectation missing prop: "???: ${expectedLabel}"`;
+        } else {
+            return `${label}malformed declaration expectation missing value: "${expectedProp}: ???"`;
+        }
+    },
+    deprecatedRootInputNotSupported: (expectation: string) =>
+        `"${expectation}" is not supported for with the used input, try calling testInlineExpects(generateStylableResults())`,
+    diagnosticsMalformed: (type: string, expectation: string, label = ``) =>
+        `${label}malformed @${type} expectation "@${type}${expectation}". format should be: "@${type}-[severity] diagnostic message"`,
+    diagnosticsNotFound: (type: string, message: string, label = ``) =>
+        `${label}${type} diagnostics not found for "${message}"`,
+    diagnosticsUnsupportedSeverity: (type: string, severity: string, label = ``) =>
+        `${label}unsupported @${type}-[severity]: "${severity}"`,
+    diagnosticsLocationMismatch: (type: string, message: string, label = ``) =>
+        `${label}expected "@${type}-[severity] "${message}" to be reported in this location, but got it somewhere else`,
+    diagnosticsWordMismatch: (type: string, expectedWord: string, message: string, label = ``) =>
+        `${label}expected word in "@${type}-[severity] word(${expectedWord}) ${message}" was not found`,
+    diagnosticsSeverityMismatch: (
+        type: string,
+        expectedSeverity: string,
+        actualSeverity: string,
+        message: string,
+        label = ``
+    ) =>
+        `${label}expected ${type} diagnostic "${message}" to be reported with "${expectedSeverity}", but it was reported with "${actualSeverity}"`,
+    diagnosticExpectedNotFound: (type: string, message: string, label = ``) =>
+        `${label}no "${type}" diagnostic found for "${message}"`,
     combine: (errors: string[]) => `\n${errors.join(`\n`)}`,
 };
diff --git a/packages/core-test-kit/test/inline-expectations.spec.ts b/packages/core-test-kit/test/inline-expectations.spec.ts
index 5d5b90e5d..ab491ec2b 100644
--- a/packages/core-test-kit/test/inline-expectations.spec.ts
+++ b/packages/core-test-kit/test/inline-expectations.spec.ts
@@ -1,13 +1,16 @@
 import {
+    generateStylableResult,
     generateStylableRoot,
     testInlineExpects,
     testInlineExpectsErrors,
 } from '@stylable/core-test-kit';
+import { transformerWarnings } from '@stylable/core/dist/stylable-transformer';
+import { STImport, CSSType, CSSClass } from '@stylable/core/dist/features';
 import { expect } from 'chai';
 
 describe('inline-expectations', () => {
-    it('should throw when expected @match amount is not found (manual)', () => {
-        const result = generateStylableRoot({
+    it('should throw when expected amount is not found (manual)', () => {
+        const result = generateStylableResult({
             entry: `/style.st.css`,
             files: {
                 '/style.st.css': {
@@ -24,8 +27,14 @@ describe('inline-expectations', () => {
             testInlineExpectsErrors.matchAmount(5, 1)
         );
     });
-    it('should throw when expected @match amount is not found (auto)', () => {
-        const result = generateStylableRoot({
+    it('should throw when expected amount is not found (auto)', () => {
+        /* simple parse amount of expected tests to compare to the actual run tests
+           and throw in case actual tests diff from expected.
+
+           `@check` is used without expectation input which is counted in the simple auto
+           expectation, but is not generating an actual test.
+        */
+        const result = generateStylableResult({
             entry: `/style.st.css`,
             files: {
                 '/style.st.css': {
@@ -40,256 +49,1058 @@ describe('inline-expectations', () => {
 
         expect(() => testInlineExpects(result)).to.throw(testInlineExpectsErrors.matchAmount(1, 0));
     });
-    it('should throw for unexpected selector', () => {
-        const result = generateStylableRoot({
+    it('should support `@` in expectation', () => {
+        const result = generateStylableResult({
             entry: `/style.st.css`,
             files: {
                 '/style.st.css': {
                     namespace: 'entry',
                     content: `
-                        /* @check .otherNamespace__root*/
-                        .root {}
+                        /* @check .entry__before\\@after-x */
+                        .before\\@after {}
                     `,
                 },
             },
         });
 
         expect(() => testInlineExpects(result)).to.throw(
-            testInlineExpectsErrors.selector(`.otherNamespace__root`, `.entry__root`)
+            testInlineExpectsErrors.selector(`.entry__before\\@after-x`, `.entry__before\\@after`)
         );
     });
-    it('should throw for unexpected declarations', () => {
-        const result = generateStylableRoot({
-            entry: `/style.st.css`,
-            files: {
-                '/style.st.css': {
-                    namespace: 'entry',
-                    content: `
-                        /* @check .entry__root {color: green;}*/
-                        .root {
-                            color: red;
-                        }
-                    `,
+    describe(`@rule`, () => {
+        it('should throw for unexpected selector', () => {
+            const result = generateStylableResult({
+                entry: `/style.st.css`,
+                files: {
+                    '/style.st.css': {
+                        namespace: 'entry',
+                        content: `
+                            /* @rule .otherNamespace__root*/
+                            .root {}
+                        `,
+                    },
                 },
-            },
+            });
+
+            expect(() => testInlineExpects(result)).to.throw(
+                testInlineExpectsErrors.selector(`.otherNamespace__root`, `.entry__root`)
+            );
         });
+        it('should throw for unexpected declarations', () => {
+            const result = generateStylableResult({
+                entry: `/style.st.css`,
+                files: {
+                    '/style.st.css': {
+                        namespace: 'entry',
+                        content: `
+                            /* @rule .entry__root {color: green;}*/
+                            .root {
+                                color: red;
+                            }
+                        `,
+                    },
+                },
+            });
 
-        expect(() => testInlineExpects(result)).to.throw(
-            testInlineExpectsErrors.declarations(`color: green`, `color: red`, `.entry__root`)
-        );
-    });
-    it('should throw for unexpected declarations (multiple variations)', () => {
-        const result = generateStylableRoot({
-            entry: `/style.st.css`,
-            files: {
-                '/style.st.css': {
-                    namespace: 'entry',
-                    content: `
-                        /* @check .entry__multi {color: green; width: 1px}*/
-                        .multi {
-                            color: green;
-                            width: 2px;
-                        }
-                        /* @check .entry__order {width: 2px; color: green;}*/
-                        .order {
-                            color: green;
-                            width: 2px;
-                        }
-                        /* @check .entry__multiline {
-                            color: red;
-                            width: 2px;
-                        }*/
-                        .multiline {
-                            color: green;
-                            width: 1px;
-                        }
-                        /* @check(only prop) .entry__malformed {color:}*/
-                        .malformed {}
-                    `,
+            expect(() => testInlineExpects(result)).to.throw(
+                testInlineExpectsErrors.declarations(`color: green`, `color: red`, `.entry__root`)
+            );
+        });
+        it('should throw for unexpected declarations (multiple variations)', () => {
+            const result = generateStylableResult({
+                entry: `/style.st.css`,
+                files: {
+                    '/style.st.css': {
+                        namespace: 'entry',
+                        content: `
+                            /* @rule .entry__multi {color: green; width: 1px}*/
+                            .multi {
+                                color: green;
+                                width: 2px;
+                            }
+                            /* @rule .entry__order {width: 2px; color: green;}*/
+                            .order {
+                                color: green;
+                                width: 2px;
+                            }
+                            /* @rule .entry__multiline {
+                                color: red;
+                                width: 2px;
+                            }*/
+                            .multiline {
+                                color: green;
+                                width: 1px;
+                            }
+                            /* @rule(only prop) .entry__malformed {color:}*/
+                            .malformed {}
+                        `,
+                    },
                 },
-            },
+            });
+
+            expect(() => testInlineExpects(result)).to.throw(
+                testInlineExpectsErrors.combine([
+                    testInlineExpectsErrors.declarations(
+                        `color: green; width: 1px`,
+                        `color: green; width: 2px`,
+                        `.entry__multi`
+                    ),
+                    testInlineExpectsErrors.declarations(
+                        `width: 2px; color: green`,
+                        `color: green; width: 2px`,
+                        `.entry__order`
+                    ),
+                    testInlineExpectsErrors.declarations(
+                        `color: red; width: 2px`,
+                        `color: green; width: 1px`,
+                        `.entry__multiline`
+                    ),
+                    testInlineExpectsErrors.ruleMalformedDecl(
+                        `color:`,
+                        `(only prop) .entry__malformed {color:}`
+                    ),
+                ])
+            );
         });
+        it('should throw for mismatch on nested rules', () => {
+            const result = generateStylableResult({
+                entry: `/style.st.css`,
+                files: {
+                    '/style.st.css': {
+                        namespace: 'entry',
+                        content: `
+                            @keyframes anim {
+                                /* @rule 50%*/
+                                100% {}
+                            }
+                        `,
+                    },
+                },
+            });
 
-        expect(() => testInlineExpects(result)).to.throw(
-            testInlineExpectsErrors.combine([
-                testInlineExpectsErrors.malformedDecl(
-                    `color:`,
-                    `(only prop) .entry__malformed {color:}`
-                ),
-                testInlineExpectsErrors.declarations(
-                    `color: green; width: 1px`,
-                    `color: green; width: 2px`,
-                    `.entry__multi`
-                ),
-                testInlineExpectsErrors.declarations(
-                    `width: 2px; color: green`,
-                    `color: green; width: 2px`,
-                    `.entry__order`
-                ),
-                testInlineExpectsErrors.declarations(
-                    `color: red; width: 2px`,
-                    `color: green; width: 1px`,
-                    `.entry__multiline`
-                ),
-            ])
-        );
-    });
-    it('should throw for at rules params', () => {
-        const result = generateStylableRoot({
-            entry: `/style.st.css`,
-            files: {
-                '/style.st.css': {
-                    namespace: 'entry',
-                    content: `
-                        /* @check entry__anim */
-                        @keyframes animX {}
+            expect(() => testInlineExpects(result)).to.throw(
+                testInlineExpectsErrors.selector(`50%`, `100%`)
+            );
+        });
+        it('should throw for mixed-in rules', () => {
+            const result = generateStylableResult({
+                entry: `/style.st.css`,
+                files: {
+                    '/style.st.css': {
+                        namespace: 'entry',
+                        content: `
+                            /* 
+                                @rule .entry__root 
+                                @rule[1] .entry__root:focus
+                            */
+                            .root {
+                                -st-mixin: mix;
+                            }
+    
+                            .mix {}
+                            .mix:hover {}
+                        `,
+                    },
+                },
+            });
 
-                        /* @check(no body) "no-body" */
-                        @charset "utf-8";
+            expect(() => testInlineExpects(result)).to.throw(
+                testInlineExpectsErrors.selector(`.entry__root:focus`, `.entry__root:hover`)
+            );
+        });
+        it('should throw for missing mixed-in rules', () => {
+            const result = generateStylableResult({
+                entry: `/style.st.css`,
+                files: {
+                    '/style.st.css': {
+                        namespace: 'entry',
+                        content: `
+                            /* 
+                                @rule .entry__root 
+                                @rule[10] .entry__root:focus
+                            */
+                            .root {
+                                -st-mixin: mix;
+                            }
+                            /*comment to break search after index over 1*/
+    
+                            .mix {}
+                        `,
+                    },
+                },
+            });
 
-                        /* @check(complex) screen and (min-width: 8px) */
-                        @media screen and (min-width: 900px) {
-                            article {
-                              padding: 1rem 3rem;
+            expect(() => testInlineExpects(result)).to.throw(
+                testInlineExpectsErrors.unfoundMixin(`[10] .entry__root:focus`)
+            );
+        });
+        it(`should support mixed-in atrule`, () => {
+            const result = generateStylableResult({
+                entry: `/style.st.css`,
+                files: {
+                    '/style.st.css': {
+                        namespace: 'entry',
+                        content: `
+                            @st-import Mix from './mix.st.css';
+
+                            /*
+                                @rule[1] mixed-params-x
+                                @rule(label)[2] mixed-params-y
+                            */
+                            .root {
+                                -st-mixin: Mix;
                             }
-                        }
-                    `,
+                        `,
+                    },
+                    '/mix.st.css': {
+                        namespace: 'mix',
+                        content: `
+                            @mix mixed-params-a {}
+                            @mix mixed-params-b {}
+                        `,
+                    },
                 },
-            },
+            });
+
+            expect(() => testInlineExpects(result)).to.throw(
+                testInlineExpectsErrors.combine([
+                    testInlineExpectsErrors.atruleParams(`mixed-params-x`, `mixed-params-a`),
+                    testInlineExpectsErrors.atruleParams(
+                        `mixed-params-y`,
+                        `mixed-params-b`,
+                        `(label): `
+                    ),
+                ])
+            );
+        });
+        it(`should throw on none supported mixed-in node type`, () => {
+            const result = generateStylableResult({
+                entry: `/style.st.css`,
+                files: {
+                    '/style.st.css': {
+                        namespace: 'entry',
+                        content: `
+                            /* @rule[1] unsupported */
+                            .root {}
+                            decl: val;
+                        `,
+                    },
+                },
+            });
+
+            expect(() => testInlineExpects(result)).to.throw(
+                testInlineExpectsErrors.unsupportedMixinNode(`decl`)
+            );
         });
+        it('should add label to thrown mismatches', () => {
+            const result = generateStylableResult({
+                entry: `/style.st.css`,
+                files: {
+                    '/style.st.css': {
+                        namespace: 'entry',
+                        content: `
+                            /* @rule(only selector) .entry__onlySelector*/
+                            .onlySelectorXXX {}
+                            /* @rule(declarations) .entry__decls {color: green;}*/
+                            .decls {color: red;}
+                        `,
+                    },
+                },
+            });
 
-        expect(() => testInlineExpects(result)).to.throw(
-            testInlineExpectsErrors.combine([
-                testInlineExpectsErrors.atruleParams(`entry__anim`, `entry__animX`),
-                testInlineExpectsErrors.atruleParams(`"no-body"`, `"utf-8"`, `(no body): `),
-                testInlineExpectsErrors.atruleParams(
-                    `screen and (min-width: 8px)`,
-                    `screen and (min-width: 900px)`,
-                    `(complex): `
-                ),
-            ])
-        );
+            expect(() => testInlineExpects(result)).to.throw(
+                testInlineExpectsErrors.combine([
+                    testInlineExpectsErrors.selector(
+                        `.entry__onlySelector`,
+                        `.entry__onlySelectorXXX`,
+                        `(only selector): `
+                    ),
+                    testInlineExpectsErrors.declarations(
+                        `color: green`,
+                        `color: red`,
+                        `.entry__decls`,
+                        `(declarations): `
+                    ),
+                ])
+            );
+        });
     });
-    it('should throw for multi check on at rules', () => {
-        const result = generateStylableRoot({
-            entry: `/style.st.css`,
-            files: {
-                '/style.st.css': {
-                    namespace: 'entry',
-                    content: `
-                        /* @check entry__anim @check[1] entry__anim */
-                        @keyframes animX {}
-                    `,
+    describe(`@atrule`, () => {
+        it('should throw for at rules params', () => {
+            const result = generateStylableResult({
+                entry: `/style.st.css`,
+                files: {
+                    '/style.st.css': {
+                        namespace: 'entry',
+                        content: `
+                            /* @atrule entry__anim */
+                            @keyframes animX {}
+    
+                            /* @atrule(no body) "no-body" */
+                            @charset "utf-8";
+    
+                            /* @atrule(complex) screen and (min-width: 8px) */
+                            @media screen and (min-width: 900px) {
+                                article {
+                                  padding: 1rem 3rem;
+                                }
+                            }
+                        `,
+                    },
                 },
-            },
+            });
+
+            expect(() => testInlineExpects(result)).to.throw(
+                testInlineExpectsErrors.combine([
+                    testInlineExpectsErrors.atruleParams(`entry__anim`, `entry__animX`),
+                    testInlineExpectsErrors.atruleParams(`"no-body"`, `"utf-8"`, `(no body): `),
+                    testInlineExpectsErrors.atruleParams(
+                        `screen and (min-width: 8px)`,
+                        `screen and (min-width: 900px)`,
+                        `(complex): `
+                    ),
+                ])
+            );
         });
+        it('should throw for mixed-in rules (unsupported)', () => {
+            const result = generateStylableResult({
+                entry: `/style.st.css`,
+                files: {
+                    '/style.st.css': {
+                        namespace: 'entry',
+                        content: `
+                            /* @atrule[16] entry__anim */
+                            @keyframes animX {}
+                        `,
+                    },
+                },
+            });
 
-        expect(() => testInlineExpects(result)).to.throw(
-            testInlineExpectsErrors.atRuleMultiTest(`@check entry__anim @check[1] entry__anim`)
-        );
+            expect(() => testInlineExpects(result)).to.throw(
+                testInlineExpectsErrors.atRuleMultiTest(`[16] entry__anim`)
+            );
+        });
+        it(`should throw on none @atrule`, () => {
+            const result = generateStylableResult({
+                entry: `/style.st.css`,
+                files: {
+                    '/style.st.css': {
+                        namespace: 'entry',
+                        content: `
+                            /* @atrule unsupported*/
+                            .root {}
+                        `,
+                    },
+                },
+            });
+
+            expect(() => testInlineExpects(result)).to.throw(
+                testInlineExpectsErrors.unsupportedNode(`@atrule`, `rule`)
+            );
+        });
     });
-    it('should throw for keyframes nested rules', () => {
-        const result = generateStylableRoot({
-            entry: `/style.st.css`,
-            files: {
-                '/style.st.css': {
-                    namespace: 'entry',
-                    content: `
-                        @keyframes anim {
-                            /* @check 50%*/
-                            100% {}
-                        }
-                    `,
+    describe(`@decl`, () => {
+        it('should throw for unexpected value', () => {
+            const result = generateStylableResult({
+                entry: `/style.st.css`,
+                files: {
+                    '/style.st.css': {
+                        namespace: 'entry',
+                        content: `
+                            .root {
+                                /* @decl color: blue */
+                                color: red;
+                            }
+                        `,
+                    },
                 },
-            },
+            });
+
+            expect(() => testInlineExpects(result)).to.throw(
+                testInlineExpectsErrors.decl(`color: blue`, `color: red`)
+            );
         });
+        it('should mark error with label', () => {
+            const result = generateStylableResult({
+                entry: `/style.st.css`,
+                files: {
+                    '/style.st.css': {
+                        namespace: 'entry',
+                        content: `
+                            .root {
+                                /* @decl(text) color: blue */
+                                color: red;
+                            }
+                        `,
+                    },
+                },
+            });
 
-        expect(() => testInlineExpects(result)).to.throw(
-            testInlineExpectsErrors.selector(`50%`, `100%`)
-        );
+            expect(() => testInlineExpects(result)).to.throw(
+                testInlineExpectsErrors.decl(`color: blue`, `color: red`, `(text): `)
+            );
+        });
+        it('should throw on malformed expectation', () => {
+            const result = generateStylableResult({
+                entry: `/style.st.css`,
+                files: {
+                    '/style.st.css': {
+                        namespace: 'entry',
+                        content: `
+                            .root {
+                                /* @decl(only prop) color */
+                                color: red;
+
+                                /* @decl(missing value) color: */
+                                color: red;
+                                
+                                /* @decl(missing prop) : red */
+                                color: red;
+                            }
+                        `,
+                    },
+                },
+            });
+
+            expect(() => testInlineExpects(result)).to.throw(
+                testInlineExpectsErrors.combine([
+                    testInlineExpectsErrors.declMalformed(`color`, ``, `(only prop): `),
+                    testInlineExpectsErrors.declMalformed(`color`, ``, `(missing value): `),
+                    testInlineExpectsErrors.declMalformed(``, `red`, `(missing prop): `),
+                ])
+            );
+        });
+        it(`should throw on none declaration node`, () => {
+            const result = generateStylableResult({
+                entry: `/style.st.css`,
+                files: {
+                    '/style.st.css': {
+                        namespace: 'entry',
+                        content: `
+                            /* @decl(on rule) color: red*/
+                            .root {}
+                            
+                            /* @decl(on atrule) color: red*/
+                            @keyframes a {}
+                        `,
+                    },
+                },
+            });
+
+            expect(() => testInlineExpects(result)).to.throw(
+                testInlineExpectsErrors.combine([
+                    testInlineExpectsErrors.unsupportedNode(`@decl`, `rule`, `(on rule): `),
+                    testInlineExpectsErrors.unsupportedNode(`@decl`, `atrule`, `(on atrule): `),
+                ])
+            );
+        });
+        it('should not throw when valid', () => {
+            const result = generateStylableResult({
+                entry: `/style.st.css`,
+                files: {
+                    '/style.st.css': {
+                        namespace: 'entry',
+                        content: `
+                            .root {
+                                /* @decl color: green */
+                                color: green;
+
+                                /* @decl(no-spaces)color:green */
+                                color: green;
+                                
+                                /* @decl(all-spaces)  color  :      green */
+                                color: green;
+                            }
+                            
+                        `,
+                    },
+                },
+            });
+
+            expect(() => testInlineExpects(result)).to.not.throw();
+        });
     });
-    it('should throw for mixed in rules', () => {
-        const result = generateStylableRoot({
-            entry: `/style.st.css`,
-            files: {
-                '/style.st.css': {
-                    namespace: 'entry',
-                    content: `
-                        /* 
-                            @check .entry__root 
-                            @check[1] .entry__root:focus
-                        */
-                        .root {
-                            -st-mixin: mix;
-                        }
+    describe(`@analyze`, () => {
+        it(`should throw on malformed expectation`, () => {
+            const result = generateStylableResult({
+                entry: `/style.st.css`,
+                files: {
+                    '/style.st.css': {
+                        namespace: 'entry',
+                        content: `
+                            /* @analyze- */
+                            .root {}
 
-                        .mix {}
-                        .mix:hover {}
-                    `,
+                            /* @analyze-warn */
+                            .root {}
+                            
+                            /* @analyze-warn(label) */
+                            .root {}
+                        `,
+                    },
                 },
-            },
+            });
+
+            expect(() => testInlineExpects(result)).to.throw(
+                testInlineExpectsErrors.combine([
+                    testInlineExpectsErrors.diagnosticsMalformed(`analyze`, `-`),
+                    testInlineExpectsErrors.diagnosticsMalformed(`analyze`, `-warn`),
+                    testInlineExpectsErrors.diagnosticsMalformed(
+                        `analyze`,
+                        `-warn(label)`,
+                        `(label): `
+                    ),
+                ])
+            );
+        });
+        it(`should throw for backwards compatibility (@analyze is not supported with just AST root)`, () => {
+            const result = generateStylableRoot({
+                entry: `/style.st.css`,
+                files: {
+                    '/style.st.css': {
+                        namespace: 'entry',
+                        content: `
+                            /* @analyze-warn message */
+                            .root {}
+                        `,
+                    },
+                },
+            });
+
+            expect(() => testInlineExpects(result)).to.throw(
+                testInlineExpectsErrors.deprecatedRootInputNotSupported(`@analyze-warn message`)
+            );
         });
+        it(`should not throw when diagnostic is matched`, () => {
+            const result = generateStylableResult({
+                entry: `/style.st.css`,
+                files: {
+                    '/style.st.css': {
+                        namespace: 'entry',
+                        content: `
+                            /* @analyze-warn ${CSSType.diagnostics.UNSCOPED_TYPE_SELECTOR(`div`)} */
+                            div {}
+                        `,
+                    },
+                },
+            });
 
-        expect(() => testInlineExpects(result)).to.throw(
-            testInlineExpectsErrors.selector(`.entry__root:focus`, `.entry__root:hover`)
-        );
+            expect(() => testInlineExpects(result)).to.not.throw();
+        });
+        it(`should throw on unsupported severity`, () => {
+            const result = generateStylableResult({
+                entry: `/style.st.css`,
+                files: {
+                    '/style.st.css': {
+                        namespace: 'entry',
+                        content: `
+                            /* @analyze-unknown diagnostic message */
+                            .root {}
+
+                            /* @analyze-unknown(label) diagnostic message */
+                            .root {}
+                        `,
+                    },
+                },
+            });
+
+            expect(() => testInlineExpects(result)).to.throw(
+                testInlineExpectsErrors.combine([
+                    testInlineExpectsErrors.diagnosticsUnsupportedSeverity(`analyze`, `unknown`),
+                    testInlineExpectsErrors.diagnosticsUnsupportedSeverity(
+                        `analyze`,
+                        `unknown`,
+                        `(label): `
+                    ),
+                ])
+            );
+        });
+        it(`should throw on possible location mismatch`, () => {
+            const result = generateStylableResult({
+                entry: `/style.st.css`,
+                files: {
+                    '/style.st.css': {
+                        namespace: 'entry',
+                        content: `
+                            /* 
+                                @analyze-warn ${CSSType.diagnostics.UNSCOPED_TYPE_SELECTOR(`div`)}
+                                @analyze-warn(label) ${CSSType.diagnostics.UNSCOPED_TYPE_SELECTOR(
+                                    `div`
+                                )}
+                            */
+                            .root {}
+
+                            div {}
+                        `,
+                    },
+                },
+            });
+
+            expect(() => testInlineExpects(result)).to.throw(
+                testInlineExpectsErrors.combine([
+                    testInlineExpectsErrors.diagnosticsLocationMismatch(
+                        `analyze`,
+                        CSSType.diagnostics.UNSCOPED_TYPE_SELECTOR(`div`)
+                    ),
+                    testInlineExpectsErrors.diagnosticsLocationMismatch(
+                        `analyze`,
+                        CSSType.diagnostics.UNSCOPED_TYPE_SELECTOR(`div`),
+                        `(label): `
+                    ),
+                ])
+            );
+        });
+        it(`should throw on word mismatch`, () => {
+            const result = generateStylableResult({
+                entry: `/style.st.css`,
+                files: {
+                    '/style.st.css': {
+                        namespace: 'entry',
+                        content: `
+                        /* @analyze-warn word(single) ${CSSType.diagnostics.UNSCOPED_TYPE_SELECTOR(
+                            `div`
+                        )} */
+                        div {}
+                        
+                        /* @analyze-warn(many words) word(one two) ${CSSType.diagnostics.UNSCOPED_TYPE_SELECTOR(
+                            `div`
+                        )} */
+                        div {}
+                        `,
+                    },
+                },
+            });
+
+            expect(() => testInlineExpects(result)).to.throw(
+                testInlineExpectsErrors.combine([
+                    testInlineExpectsErrors.diagnosticsWordMismatch(
+                        `analyze`,
+                        `single`,
+                        CSSType.diagnostics.UNSCOPED_TYPE_SELECTOR(`div`)
+                    ),
+                    testInlineExpectsErrors.diagnosticsWordMismatch(
+                        `analyze`,
+                        `one two`,
+                        CSSType.diagnostics.UNSCOPED_TYPE_SELECTOR(`div`),
+                        `(many words): `
+                    ),
+                ])
+            );
+        });
+        it(`should throw on severity mismatch`, () => {
+            const result = generateStylableResult({
+                entry: `/style.st.css`,
+                files: {
+                    '/style.st.css': {
+                        namespace: 'entry',
+                        content: `
+                        /* @analyze-error ${CSSType.diagnostics.UNSCOPED_TYPE_SELECTOR(`div`)} */
+                        div {}
+
+                        /* @analyze-error(label) ${CSSType.diagnostics.UNSCOPED_TYPE_SELECTOR(
+                            `div`
+                        )} */
+                        div {}
+                        `,
+                    },
+                },
+            });
+
+            expect(() => testInlineExpects(result)).to.throw(
+                testInlineExpectsErrors.combine([
+                    testInlineExpectsErrors.diagnosticsSeverityMismatch(
+                        `analyze`,
+                        `error`,
+                        `warning`,
+                        CSSType.diagnostics.UNSCOPED_TYPE_SELECTOR(`div`)
+                    ),
+                    testInlineExpectsErrors.diagnosticsSeverityMismatch(
+                        `analyze`,
+                        `error`,
+                        `warning`,
+                        CSSType.diagnostics.UNSCOPED_TYPE_SELECTOR(`div`),
+                        `(label): `
+                    ),
+                ])
+            );
+        });
+        it(`should throw on missing diagnostic`, () => {
+            const result = generateStylableResult({
+                entry: `/style.st.css`,
+                files: {
+                    '/style.st.css': {
+                        namespace: 'entry',
+                        content: `
+                            /* @analyze-warn fake diagnostic message */
+                            .root {}
+                            
+                            /* @analyze-warn(label) fake diagnostic message */
+                            .root {}
+                        `,
+                    },
+                },
+            });
+
+            expect(() => testInlineExpects(result)).to.throw(
+                testInlineExpectsErrors.combine([
+                    testInlineExpectsErrors.diagnosticExpectedNotFound(
+                        `analyze`,
+                        `fake diagnostic message`
+                    ),
+                    testInlineExpectsErrors.diagnosticExpectedNotFound(
+                        `analyze`,
+                        `fake diagnostic message`,
+                        `(label): `
+                    ),
+                ])
+            );
+        });
+        it(`should check against rawAst (for nodes that are removed in transform)`, () => {
+            const result = generateStylableResult({
+                entry: `/style.st.css`,
+                files: {
+                    '/style.st.css': {
+                        namespace: 'entry',
+                        content: `
+                            /* @analyze-warn word(comp) ${STImport.diagnostics.DEFAULT_IMPORT_IS_LOWER_CASE()} */
+                            @st-import comp from "./x.st.css";
+                            
+                            /* @analyze-warn ${STImport.diagnostics.ST_IMPORT_EMPTY_FROM()} */
+                            @st-import comp from "./x.st.css";
+                        `,
+                    },
+                },
+            });
+
+            expect(() => testInlineExpects(result)).to.throw(
+                testInlineExpectsErrors.diagnosticExpectedNotFound(
+                    `analyze`,
+                    STImport.diagnostics.ST_IMPORT_EMPTY_FROM()
+                )
+            );
+        });
     });
-    it('should throw for unfound mixin rules', () => {
-        const result = generateStylableRoot({
-            entry: `/style.st.css`,
-            files: {
-                '/style.st.css': {
-                    namespace: 'entry',
-                    content: `
-                        /* 
-                            @check .entry__root 
-                            @check[10] .entry__root:focus
-                        */
+    describe(`@transform`, () => {
+        it(`should throw on malformed expectation`, () => {
+            const result = generateStylableResult({
+                entry: `/style.st.css`,
+                files: {
+                    '/style.st.css': {
+                        namespace: 'entry',
+                        content: `
+                            /* @transform- */
+                            .root {}
+
+                            /* @transform-warn */
+                            .root {}
+                            
+                            /* @transform-warn(label) */
+                            .root {}
+                        `,
+                    },
+                },
+            });
+
+            expect(() => testInlineExpects(result)).to.throw(
+                testInlineExpectsErrors.combine([
+                    testInlineExpectsErrors.diagnosticsMalformed(`transform`, `-`),
+                    testInlineExpectsErrors.diagnosticsMalformed(`transform`, `-warn`),
+                    testInlineExpectsErrors.diagnosticsMalformed(
+                        `transform`,
+                        `-warn(label)`,
+                        `(label): `
+                    ),
+                ])
+            );
+        });
+        it(`should throw for backwards compatibility (@transform is not supported with just AST root)`, () => {
+            const result = generateStylableRoot({
+                entry: `/style.st.css`,
+                files: {
+                    '/style.st.css': {
+                        namespace: 'entry',
+                        content: `
+                            /* @transform-warn message */
+                            .root {}
+                        `,
+                    },
+                },
+            });
+
+            expect(() => testInlineExpects(result)).to.throw(
+                testInlineExpectsErrors.deprecatedRootInputNotSupported(`@transform-warn message`)
+            );
+        });
+        it(`should not throw when diagnostic is matched`, () => {
+            const result = generateStylableResult({
+                entry: `/style.st.css`,
+                files: {
+                    '/style.st.css': {
+                        namespace: 'entry',
+                        content: `
+                        @st-import [unknown] from './other.st.css';
+
                         .root {
-                            -st-mixin: mix;
+                            /* @transform-error ${CSSClass.diagnostics.CANNOT_EXTEND_UNKNOWN_SYMBOL(
+                                `unknown`
+                            )}*/
+                            -st-extends: unknown;
                         }
-                        /*comment to break search after index over 1*/
+                        `,
+                    },
+                    '/other.st.css': {
+                        namespace: 'other',
+                        content: ``,
+                    },
+                },
+            });
 
-                        .mix {}
-                    `,
+            expect(() => testInlineExpects(result)).to.not.throw();
+        });
+        it(`should throw on unsupported severity`, () => {
+            const result = generateStylableResult({
+                entry: `/style.st.css`,
+                files: {
+                    '/style.st.css': {
+                        namespace: 'entry',
+                        content: `
+                            /* @transform-unknown diagnostic message */
+                            .root {}
+
+                            /* @transform-unknown(label) diagnostic message */
+                            .root {}
+                        `,
+                    },
                 },
-            },
+            });
+
+            expect(() => testInlineExpects(result)).to.throw(
+                testInlineExpectsErrors.combine([
+                    testInlineExpectsErrors.diagnosticsUnsupportedSeverity(`transform`, `unknown`),
+                    testInlineExpectsErrors.diagnosticsUnsupportedSeverity(
+                        `transform`,
+                        `unknown`,
+                        `(label): `
+                    ),
+                ])
+            );
         });
+        it(`should throw on possible location mismatch`, () => {
+            const result = generateStylableResult({
+                entry: `/style.st.css`,
+                files: {
+                    '/style.st.css': {
+                        namespace: 'entry',
+                        content: `
+                            @st-import [unknown] from './unknown.st.css';
 
-        expect(() => testInlineExpects(result)).to.throw(
-            testInlineExpectsErrors.unfoundMixin(`[10] .entry__root:focus`)
-        );
+                            /* 
+                                @transform-warn ${STImport.diagnostics.UNKNOWN_IMPORTED_FILE(
+                                    `./unknown.st.css`
+                                )}
+                                @transform-warn(label) ${STImport.diagnostics.UNKNOWN_IMPORTED_FILE(
+                                    `./unknown.st.css`
+                                )}
+                            */
+                            .root {}
+                        `,
+                    },
+                },
+            });
+
+            expect(() => testInlineExpects(result)).to.throw(
+                testInlineExpectsErrors.combine([
+                    testInlineExpectsErrors.diagnosticsLocationMismatch(
+                        `transform`,
+                        STImport.diagnostics.UNKNOWN_IMPORTED_FILE(`./unknown.st.css`)
+                    ),
+                    testInlineExpectsErrors.diagnosticsLocationMismatch(
+                        `transform`,
+                        STImport.diagnostics.UNKNOWN_IMPORTED_FILE(`./unknown.st.css`),
+                        `(label): `
+                    ),
+                ])
+            );
+        });
+        it(`should throw on word mismatch`, () => {
+            const result = generateStylableResult({
+                entry: `/style.st.css`,
+                files: {
+                    '/style.st.css': {
+                        namespace: 'entry',
+                        content: `
+                        /* @transform-warn word(something-else) ${transformerWarnings.UNKNOWN_PSEUDO_ELEMENT(
+                            `not-a-real-thing`
+                        )} */
+                        .root::not-a-real-thing {}
+                        
+                        /* @transform-warn(many) word(a b c) ${transformerWarnings.UNKNOWN_PSEUDO_ELEMENT(
+                            `not-a-real-thing`
+                        )} */
+                        .root::not-a-real-thing {}
+                        `,
+                    },
+                },
+            });
+
+            expect(() => testInlineExpects(result)).to.throw(
+                testInlineExpectsErrors.combine([
+                    testInlineExpectsErrors.diagnosticsWordMismatch(
+                        `transform`,
+                        `something-else`,
+                        transformerWarnings.UNKNOWN_PSEUDO_ELEMENT(`not-a-real-thing`)
+                    ),
+                    testInlineExpectsErrors.diagnosticsWordMismatch(
+                        `transform`,
+                        `a b c`,
+                        transformerWarnings.UNKNOWN_PSEUDO_ELEMENT(`not-a-real-thing`),
+                        `(many): `
+                    ),
+                ])
+            );
+        });
+        it(`should throw on severity mismatch`, () => {
+            const result = generateStylableResult({
+                entry: `/style.st.css`,
+                files: {
+                    '/style.st.css': {
+                        namespace: 'entry',
+                        content: `
+                        /* @transform-info ${transformerWarnings.UNKNOWN_PSEUDO_ELEMENT(
+                            `not-a-real-thing`
+                        )} */
+                        .root::not-a-real-thing {}
+                        
+                        /* @transform-error(label) ${transformerWarnings.UNKNOWN_PSEUDO_ELEMENT(
+                            `not-a-real-thing`
+                        )} */
+                        .root::not-a-real-thing {}
+                        `,
+                    },
+                },
+            });
+
+            expect(() => testInlineExpects(result)).to.throw(
+                testInlineExpectsErrors.combine([
+                    testInlineExpectsErrors.diagnosticsSeverityMismatch(
+                        `transform`,
+                        `info`,
+                        `warning`,
+                        transformerWarnings.UNKNOWN_PSEUDO_ELEMENT(`not-a-real-thing`)
+                    ),
+                    testInlineExpectsErrors.diagnosticsSeverityMismatch(
+                        `transform`,
+                        `error`,
+                        `warning`,
+                        transformerWarnings.UNKNOWN_PSEUDO_ELEMENT(`not-a-real-thing`),
+                        `(label): `
+                    ),
+                ])
+            );
+        });
+        it(`should throw on missing diagnostic`, () => {
+            const result = generateStylableResult({
+                entry: `/style.st.css`,
+                files: {
+                    '/style.st.css': {
+                        namespace: 'entry',
+                        content: `
+                            /* @transform-warn fake diagnostic message */
+                            .root {}
+                            
+                            /* @transform-warn(label) fake diagnostic message */
+                            .root {}
+                        `,
+                    },
+                },
+            });
+
+            expect(() => testInlineExpects(result)).to.throw(
+                testInlineExpectsErrors.combine([
+                    testInlineExpectsErrors.diagnosticExpectedNotFound(
+                        `transform`,
+                        `fake diagnostic message`
+                    ),
+                    testInlineExpectsErrors.diagnosticExpectedNotFound(
+                        `transform`,
+                        `fake diagnostic message`,
+                        `(label): `
+                    ),
+                ])
+            );
+        });
+        it(`should check against rawAst (for nodes that are removed in transform)`, () => {
+            const result = generateStylableResult({
+                entry: `/style.st.css`,
+                files: {
+                    '/style.st.css': {
+                        namespace: 'entry',
+                        content: `
+                            /* @transform-warn(should match) word(./x.st.css) ${STImport.diagnostics.UNKNOWN_IMPORTED_FILE(
+                                `./x.st.css`
+                            )} */
+                            @st-import A from "./x.st.css";
+
+                            /* @transform-warn(should fail) ${STImport.diagnostics.ST_IMPORT_EMPTY_FROM()} */
+                            @st-import B from "./x.st.css";
+                        `,
+                    },
+                },
+            });
+
+            // only the second expectation should fail - the first one should be found
+            expect(() => testInlineExpects(result)).to.throw(
+                testInlineExpectsErrors.diagnosticExpectedNotFound(
+                    `transform`,
+                    STImport.diagnostics.ST_IMPORT_EMPTY_FROM()
+                )
+            );
+        });
     });
-    it('should add label to thrown miss matches', () => {
-        const result = generateStylableRoot({
-            entry: `/style.st.css`,
-            files: {
-                '/style.st.css': {
-                    namespace: 'entry',
-                    content: `
-                        /* @check(only selector) .entry__onlySelector*/
-                        .onlySelectorXXX {}
-                        /* @check(declarations) .entry__decls {color: green;}*/
-                        .decls {color: red;}
-                    `,
+    describe(`@check`, () => {
+        it(`should proxy to @rule and @atrule`, () => {
+            const result = generateStylableResult({
+                entry: `/style.st.css`,
+                files: {
+                    '/style.st.css': {
+                        namespace: 'entry',
+                        content: `
+                            /* @check .otherNamespace__root*/
+                            .root {}
+
+                            /* @check entry__anim */
+                            @keyframes animX {}
+                        `,
+                    },
                 },
-            },
+            });
+
+            expect(() => testInlineExpects(result)).to.throw(
+                testInlineExpectsErrors.combine([
+                    testInlineExpectsErrors.selector(`.otherNamespace__root`, `.entry__root`),
+                    testInlineExpectsErrors.atruleParams(`entry__anim`, `entry__animX`),
+                ])
+            );
         });
+        it(`should throw on none @rule or @atrule`, () => {
+            const result = generateStylableResult({
+                entry: `/style.st.css`,
+                files: {
+                    '/style.st.css': {
+                        namespace: 'entry',
+                        content: `
+                            .root {
+                                /* @check unsupported*/
+                                decl: val;
+                            }
+                        `,
+                    },
+                },
+            });
 
-        expect(() => testInlineExpects(result)).to.throw(
-            testInlineExpectsErrors.combine([
-                testInlineExpectsErrors.selector(
-                    `.entry__onlySelector`,
-                    `.entry__onlySelectorXXX`,
-                    `(only selector): `
-                ),
-                testInlineExpectsErrors.declarations(
-                    `color: green`,
-                    `color: red`,
-                    `.entry__decls`,
-                    `(declarations): `
-                ),
-            ])
-        );
+            expect(() => testInlineExpects(result)).to.throw(
+                testInlineExpectsErrors.unsupportedNode(`@check`, `decl`)
+            );
+        });
     });
 });