@emulsify/core 4.4.0 → 4.5.0

package/config/vite/utils/twig-component-resolver.js

@@ -0,0 +1,316 @@
+/**
+ * @file Node-safe component template resolution shared by Twig compilation and audits.
+ *
+ * Callers own the grouping-directory cache so a build can invalidate it on
+ * filesystem changes and an audit can discard it after each pass.
+ */
+
+import fs from 'node:fs';
+import { basename, isAbsolute, relative, resolve } from 'node:path';
+import { toPosixPath } from './paths.js';
+import { DEFAULT_SKIP_DIRS } from './source-directory-skips.js';
+import { unique } from '../../../src/extensions/shared/lists.js';
+
+/**
+ * Build likely filesystem candidates for a Twig template reference.
+ *
+ * @param {string} baseDir - Directory used as the resolution root.
+ * @param {string} templatePath - Template path from Twig source.
+ * @returns {string[]} Candidate absolute paths.
+ */
+export const buildTemplateFileCandidates = (baseDir, templatePath) => {
+  const normalizedTemplatePath = toPosixPath(templatePath);
+  const withoutTwigExt = normalizedTemplatePath.replace(/\.twig$/i, '');
+  const stem = basename(withoutTwigExt);
+
+  return unique(
+    [
+      resolve(baseDir, normalizedTemplatePath),
+      resolve(baseDir, `${normalizedTemplatePath}.twig`),
+      resolve(baseDir, `${normalizedTemplatePath}.html.twig`),
+      resolve(baseDir, withoutTwigExt, `${stem}.twig`),
+      resolve(baseDir, withoutTwigExt, `${stem}.html.twig`),
+    ].filter(Boolean),
+  );
+};
+
+/**
+ * Determine whether a file path is equal to or below a candidate root.
+ *
+ * @param {string} root - Absolute root path.
+ * @param {string} filePath - Absolute file path.
+ * @returns {boolean} TRUE when the file belongs to the root.
+ */
+export const isWithinRoot = (root, filePath) => {
+  const rootRelativePath = relative(root, filePath);
+  return (
+    rootRelativePath === '' ||
+    (!!rootRelativePath &&
+      !rootRelativePath.startsWith('..') &&
+      !isAbsolute(rootRelativePath))
+  );
+};
+
+/**
+ * Return the first component template candidate contained by its configured root.
+ *
+ * Both lexical and real paths are checked so `..` segments and symlinks cannot
+ * escape the component root.
+ *
+ * @param {Iterable<string>} paths - Candidate absolute paths in precedence order.
+ * @param {string} componentRoot - Absolute component root path.
+ * @returns {string|undefined} Existing component template path.
+ */
+const findExistingComponentTemplateFile = (paths, componentRoot) => {
+  const absoluteRoot = resolve(componentRoot);
+  let realRoot;
+
+  try {
+    realRoot = fs.realpathSync(absoluteRoot);
+  } catch {
+    return undefined;
+  }
+
+  for (const filePath of paths) {
+    if (!filePath) continue;
+    const absoluteFilePath = resolve(filePath);
+    if (!isWithinRoot(absoluteRoot, absoluteFilePath)) {
+      continue;
+    }
+
+    try {
+      if (
+        fs.statSync(absoluteFilePath).isFile() &&
+        isWithinRoot(realRoot, fs.realpathSync(absoluteFilePath))
+      ) {
+        return filePath;
+      }
+    } catch {
+      // A missing or unreadable candidate does not prevent later matches.
+    }
+  }
+  return undefined;
+};
+
+/**
+ * Resolve Twig namespace syntax to a namespace root and relative path.
+ *
+ * @param {string} templatePath - Template reference from Twig source.
+ * @param {Record<string, string>} [namespaces={}] - Namespace root map.
+ * @returns {{ namespace: string, root: string, path: string }|null}
+ *   Namespace lookup result.
+ */
+export const parseTwigNamespaceReference = (templatePath, namespaces = {}) => {
+  const namespaceNames = Object.keys(namespaces);
+  const atNamespace = templatePath.match(/^@([^/]+)\/(.+)$/);
+  if (atNamespace && namespaces[atNamespace[1]]) {
+    return {
+      namespace: atNamespace[1],
+      root: namespaces[atNamespace[1]],
+      path: atNamespace[2],
+    };
+  }
+
+  const doubleColon = templatePath.match(/^([^:]+)::(.+)$/);
+  if (doubleColon && namespaces[doubleColon[1]]) {
+    return {
+      namespace: doubleColon[1],
+      root: namespaces[doubleColon[1]],
+      path: doubleColon[2],
+    };
+  }
+
+  const singleColon = templatePath.match(/^([^:/.]+):(.+)$/);
+  if (singleColon && namespaces[singleColon[1]]) {
+    return {
+      namespace: singleColon[1],
+      root: namespaces[singleColon[1]],
+      path: singleColon[2],
+    };
+  }
+
+  const slashNamespace = namespaceNames.find((namespace) =>
+    templatePath.startsWith(`${namespace}/`),
+  );
+  if (slashNamespace) {
+    return {
+      namespace: slashNamespace,
+      // Namespace names come from the normalized Twig namespace map.
+      root: namespaces[slashNamespace],
+      path: templatePath.slice(slashNamespace.length + 1),
+    };
+  }
+
+  return null;
+};
+
+/**
+ * Return grouping directories below the configured component root.
+ *
+ * Breadth-first traversal preserves direct and one-level behavior before
+ * searching deeper groups. Siblings use UTF-16 code-unit order so duplicate
+ * shorthand names resolve consistently across filesystems.
+ *
+ * @param {string} componentRoot - Absolute component root path.
+ * @param {Map<string, string[]>} componentGroupRootsCache - Caller-scoped directory cache.
+ * @returns {string[]} Absolute grouping directory paths.
+ */
+const componentGroupRoots = (componentRoot, componentGroupRootsCache) => {
+  if (!componentRoot) return [];
+
+  const absoluteRoot = resolve(componentRoot);
+  if (componentGroupRootsCache.has(absoluteRoot)) {
+    return componentGroupRootsCache.get(absoluteRoot);
+  }
+
+  const groupRoots = [];
+  const pendingDirectories = [absoluteRoot];
+
+  for (let index = 0; index < pendingDirectories.length; index += 1) {
+    const directory = pendingDirectories[index];
+    let entries;
+
+    try {
+      entries = fs.readdirSync(directory, { withFileTypes: true });
+    } catch {
+      continue;
+    }
+
+    const childDirectories = entries
+      .filter(
+        (entry) =>
+          entry.isDirectory() && !DEFAULT_SKIP_DIRS.includes(entry.name),
+      )
+      .sort(({ name: left }, { name: right }) =>
+        left === right ? 0 : left < right ? -1 : 1,
+      )
+      .map((entry) => resolve(directory, entry.name))
+      .filter((childDirectory) => isWithinRoot(absoluteRoot, childDirectory));
+
+    groupRoots.push(...childDirectories);
+    pendingDirectories.push(...childDirectories);
+  }
+
+  componentGroupRootsCache.set(absoluteRoot, groupRoots);
+  return groupRoots;
+};
+
+/**
+ * Resolve a component reference through recursively grouped directories.
+ *
+ * Project-scoped component IDs can use the component name (`project:button`)
+ * even when projects organize components under grouping paths such as
+ * `atoms/text`.
+ *
+ * @param {string} templatePath - Component-relative template reference.
+ * @param {string} componentRoot - Absolute component root path.
+ * @param {Map<string, string[]>} componentGroupRootsCache - Caller-scoped directory cache.
+ * @returns {string|null} Existing template path when found.
+ */
+const resolveGroupedComponentTemplate = (
+  templatePath,
+  componentRoot,
+  componentGroupRootsCache,
+) => {
+  const groupRoots = componentGroupRoots(
+    componentRoot,
+    componentGroupRootsCache,
+  );
+  function* candidates() {
+    for (const groupRoot of groupRoots) {
+      yield* buildTemplateFileCandidates(groupRoot, templatePath);
+    }
+  }
+
+  return findExistingComponentTemplateFile(candidates(), componentRoot) || null;
+};
+
+/**
+ * Resolve shorthand component references against the components namespace.
+ *
+ * @param {string} templatePath - Template reference from Twig source.
+ * @param {string} componentRoot - Absolute component root path.
+ * @param {Map<string, string[]>} componentGroupRootsCache - Caller-scoped directory cache.
+ * @returns {string|null} Existing template path when found.
+ */
+const resolveComponentShorthandReference = (
+  templatePath,
+  componentRoot,
+  componentGroupRootsCache,
+) => {
+  if (!componentRoot || templatePath.startsWith('.')) return null;
+
+  const shorthandPath =
+    templatePath.startsWith('@') && !templatePath.includes('/')
+      ? templatePath.slice(1)
+      : templatePath;
+  const directComponentPath = findExistingComponentTemplateFile(
+    buildTemplateFileCandidates(componentRoot, shorthandPath),
+    componentRoot,
+  );
+  if (directComponentPath) {
+    return directComponentPath;
+  }
+
+  // A bare directory path keeps every segment; only explicit namespace syntax
+  // can drop its prefix before searching component groups.
+  const genericNamespace = templatePath.match(/^(?:@[^/:]+\/|@?[^/:]+:)(.+)$/);
+  if (!genericNamespace) {
+    return null;
+  }
+
+  const genericComponentPath = genericNamespace[1];
+
+  return (
+    findExistingComponentTemplateFile(
+      buildTemplateFileCandidates(componentRoot, genericComponentPath),
+      componentRoot,
+    ) ||
+    resolveGroupedComponentTemplate(
+      genericComponentPath,
+      componentRoot,
+      componentGroupRootsCache,
+    )
+  );
+};
+
+/**
+ * Resolve component namespace paths and project-scoped component shorthand.
+ *
+ * Configured non-component namespaces remain scoped to their own roots. Direct
+ * candidates precede grouped candidates, which retain breadth-first/UTF-16
+ * order for duplicate component names.
+ *
+ * @param {string} templatePath - Template reference from Twig source.
+ * @param {Record<string, string>} namespaces - Normalized namespace root map.
+ * @param {Map<string, string[]>} componentGroupRootsCache - Caller-scoped directory cache.
+ * @returns {string|null} Existing component template path when found.
+ */
+export const resolveComponentReference = (
+  templatePath,
+  namespaces,
+  componentGroupRootsCache,
+) => {
+  const namespaced = parseTwigNamespaceReference(templatePath, namespaces);
+  if (namespaced) {
+    if (namespaced.namespace !== 'components') return null;
+
+    return (
+      findExistingComponentTemplateFile(
+        buildTemplateFileCandidates(namespaced.root, namespaced.path),
+        namespaced.root,
+      ) ||
+      resolveGroupedComponentTemplate(
+        namespaced.path,
+        namespaced.root,
+        componentGroupRootsCache,
+      )
+    );
+  }
+
+  return resolveComponentShorthandReference(
+    templatePath,
+    namespaces?.components,
+    componentGroupRootsCache,
+  );
+};

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@emulsify/core",
-  "version": "4.4.0",
+  "version": "4.5.0",
   "description": "Bundled tooling for Storybook development + Vite Build",
   "keywords": [
     "component library",
@@ -52,6 +52,7 @@
     "assets/**/*",
     "config/.prettierrc.json",
     "config/.stylelintrc.json",
+    "config/a11y-wcag22.js",
     "config/a11y.config.js",
     "config/babel.config.js",
     "config/eslint.config.js",
@@ -103,7 +104,9 @@
     "config/vite/utils/package-version.js",
     "config/vite/utils/paths.js",
     "config/vite/utils/react-singleton.js",
+    "config/vite/utils/source-directory-skips.js",
     "config/vite/utils/source-maps.js",
+    "config/vite/utils/twig-component-resolver.js",
     "config/vite/vite.config.js",
     "scripts/a11y.js",
     "scripts/audit-twig-stories.js",
@@ -161,6 +164,7 @@
     "./storybook/twig/include-function": "./src/storybook/twig/include-function.js",
     "./storybook/twig/source-function": "./src/storybook/twig/source-function.js",
     "./storybook/twig/source": "./src/storybook/twig/source.js",
+    "./a11y/wcag22": "./config/a11y-wcag22.js",
     "./vite": "./config/vite/vite.config.js",
     "./vite/plugins": "./config/vite/plugins.js",
     "./vite/platforms": "./config/vite/platforms.js",
@@ -195,7 +199,7 @@
     "prettier": "npm run check-node-version && prettier --check --config config/.prettierrc.json --ignore-unknown \"**/*.{js,mjs,cjs,jsx,json,yml,yaml,scss,md,twig}\"",
     "prettier-fix": "npm run check-node-version && prettier --config config/.prettierrc.json --write --ignore-unknown \"**/*.{js,mjs,cjs,jsx,json,yml,yaml,scss,md,twig}\"",
     "release:analyze": "npm run check-node-version && node scripts/verify-release-analysis.js",
-    "release:verify": "npm run check-node-version && npm run lint && npm test && npm run storybook-build && npm run fixtures:release && npm run fixtures:consumer && npm run pack:dry-run && npm run smoke:pack && npm run release:analyze",
+    "release:verify": "node scripts/release-evidence.js verify",
     "semantic-release": "npm run check-node-version && semantic-release --config ./release.config.cjs",
     "smoke:pack": "npm run check-node-version && node scripts/smoke-pack.js",
     "version:develop": "npm run check-node-version && node scripts/bump-version-from-commits.js",
@@ -208,45 +212,46 @@
   "dependencies": {
     "@babel/core": "^7.29.7",
     "@babel/eslint-parser": "^7.29.7",
+    "@babel/parser": "^7.29.8",
     "@babel/preset-env": "^7.29.7",
-    "@emulsify/cli": "^2.2.0",
+    "@emulsify/cli": "^2.4.1",
     "@eslint/js": "^9.39.5",
     "@mlnop/vite-plugin-sass-glob-import": "^6.2.0",
-    "@storybook/addon-a11y": "^10.5.8",
-    "@storybook/addon-links": "^10.5.8",
-    "@storybook/addon-themes": "^10.5.8",
-    "@storybook/react": "^10.5.8",
-    "@storybook/react-vite": "^10.5.8",
+    "@storybook/addon-a11y": "^10.6.0",
+    "@storybook/addon-links": "^10.6.0",
+    "@storybook/addon-themes": "^10.6.0",
+    "@storybook/react": "^10.6.0",
+    "@storybook/react-vite": "^10.6.0",
     "@vituum/vite-plugin-twig": "^2.0.1",
-    "autoprefixer": "^10.5.4",
+    "autoprefixer": "^10.5.6",
     "axe-core": "^4.13.0",
     "babel-preset-minify": "^0.5.2",
     "concurrently": "^10.0.5",
     "eslint": "^9.39.5",
     "eslint-config-prettier": "^10.1.8",
     "eslint-plugin-import": "^2.32.0",
-    "eslint-plugin-jest": "^29.16.1",
+    "eslint-plugin-jest": "^29.16.6",
     "eslint-plugin-prettier": "^5.5.6",
     "eslint-plugin-security": "^4.0.1",
-    "eslint-plugin-storybook": "^10.5.8",
+    "eslint-plugin-storybook": "^10.6.0",
     "glob": "^13.0.6",
-    "jest": "^30.4.2",
-    "jest-environment-jsdom": "^30.4.1",
-    "js-yaml": "^5.3.0",
+    "jest": "^30.5.1",
+    "jest-environment-jsdom": "^30.5.1",
+    "js-yaml": "^5.4.1",
     "normalize.css": "^8.0.1",
     "open-cli": "^9.0.0",
     "pa11y": "^9.1.1",
-    "postcss": "^8.5.26",
+    "postcss": "^8.5.28",
     "postcss-scss": "^4.0.9",
-    "sass": "^1.102.0",
-    "storybook": "^10.5.8",
-    "stylelint": "^17.14.1",
+    "sass": "^1.104.0",
+    "storybook": "^10.6.0",
+    "stylelint": "^17.15.0",
     "stylelint-config-standard-scss": "^17.0.0",
     "stylelint-prettier": "^5.0.3",
     "stylelint-selector-bem-pattern": "^5.0.0",
     "twig": "^3.0.0",
     "twig-drupal-filters": "^3.2.0",
-    "vite": "^8.2.1"
+    "vite": "^8.3.0"
   },
   "devDependencies": {
     "@commitlint/cli": "^21.2.2",
@@ -256,10 +261,10 @@
     "@semantic-release/npm": "^13.1.5",
     "@semantic-release/release-notes-generator": "^14.1.1",
     "husky": "^9.1.7",
-    "lint-staged": "^17.3.0",
-    "puppeteer": "^25.7.0",
-    "react": "^19.2.8",
-    "react-dom": "^19.2.8",
+    "lint-staged": "^17.5.1",
+    "puppeteer": "^25.10.0",
+    "react": "^19.3.0",
+    "react-dom": "^19.3.0",
     "semantic-release": "^25.0.9"
   },
   "peerDependencies": {
@@ -272,13 +277,11 @@
     "minimatch@3.0.x": "^3.1.5"
   },
   "allowScripts": {
+    "fsevents@2.3.3": true,
+    "unrs-resolver@1.12.2": true,
     "@parcel/watcher@2.6.0": true,
     "esbuild@0.28.1": true,
-    "fsevents@2.3.3": true,
     "puppeteer@24.43.1": true,
-    "unrs-resolver@1.12.2": true,
-    "puppeteer@25.4.0": true,
-    "puppeteer@25.5.0": true,
-    "puppeteer@25.7.0": true
+    "puppeteer@25.10.0": true
   }
 }

package/scripts/a11y.js

@@ -15,6 +15,7 @@ import a11yConfig from '../config/a11y.config.js';
 
 // Project-specific configuration.
 let {
+  concurrency = 2,
   ignore = {},
   components = [],
   discoverStories = true,
@@ -49,10 +50,16 @@ const loadProjectA11yConfig = async (projectDir = process.cwd()) => {
 /**
  * Apply project-specific a11y config values over shared defaults.
  *
- * @param {{ignore?: object, components?: string[], discoverStories?: boolean, storybookBuildDir?: string, pa11y?: object}} config - Project config.
+ * @param {{concurrency?: number, ignore?: object, components?: string[], discoverStories?: boolean, storybookBuildDir?: string, pa11y?: object}} config - Project config.
  * @returns {void}
  */
 const applyProjectA11yConfig = (config = {}) => {
+  if (config.concurrency !== undefined) {
+    if (!Number.isSafeInteger(config.concurrency) || config.concurrency < 1) {
+      throw new Error('Accessibility concurrency must be a positive integer.');
+    }
+    concurrency = config.concurrency;
+  }
   ignore = config.ignore || ignore;
   components = Array.isArray(config.components)
     ? config.components
@@ -353,14 +360,23 @@ const logReport = ({ issues, pageUrl }) => {
   return hasIssues;
 };
 
+/**
+ * Build the requested URL consistently for scans and execution-failure reports.
+ * @param {string} name - Story ID.
+ * @param {{baseUrl?: string}} [options={}] - Storybook origin options.
+ * @returns {string} Requested story URL.
+ */
+const storyUrl = (name, { baseUrl } = {}) =>
+  `${baseUrl || resolveStorybookIframe()}?id=${name}`;
+
 /**
  * Run pa11y on a single Storybook story by its ID.
  * @param {string} name - Story ID (e.g., "components-button--primary").
  * @param {{baseUrl?: string}} [options={}] - Storybook origin options.
  * @returns {Promise<{ issues: Pa11yIssue[], pageUrl: string }>} Pa11y result.
  */
-const lintComponent = async (name, { baseUrl } = {}) =>
-  pa11y(`${baseUrl || resolveStorybookIframe()}?id=${name}`, {
+const lintComponent = async (name, options = {}) =>
+  pa11y(storyUrl(name, options), {
     includeNotices: true,
     includeWarnings: true,
     runners: ['axe'],
@@ -368,19 +384,82 @@ const lintComponent = async (name, { baseUrl } = {}) =>
   });
 
 /**
- * Lint a list of components, log reports, and exit(1) if any have issues.
+ * @typedef {Object} StoryOutcome
+ * @property {string} storyId - Selected Storybook story ID.
+ * @property {string} url - Requested story URL, even when navigation fails.
+ * @property {'completed'|'failed'} status - Scan execution outcome.
+ * @property {object} [report] - Completed Pa11y report.
+ * @property {Error} [error] - Contextual execution error with the original cause.
+ */
+
+/**
+ * Lint every selected story and report all outcomes before rejecting failures.
+ *
+ * Reportable findings set a nonzero exit status. Execution failures also reject
+ * with an AggregateError whose errors preserve story context and original causes.
  * @param {string[]} names - List of Storybook story IDs.
  * @param {{baseUrl?: string}} [options={}] - Storybook origin options.
  * @returns {Promise<void>}
  */
 const lintReportAndExit = async (names, options = {}) => {
-  const results = await Promise.all(
-    names.map((name) => lintComponent(name, options)),
+  /** @type {StoryOutcome[]} */
+  const outcomes = new Array(names.length);
+  let nextIndex = 0;
+  const worker = async () => {
+    while (nextIndex < names.length) {
+      const index = nextIndex;
+      nextIndex += 1;
+      const storyId = names[index];
+      const url = storyUrl(storyId, options);
+      try {
+        const report = await lintComponent(storyId, options);
+        outcomes[index] = { storyId, url, status: 'completed', report };
+      } catch (cause) {
+        const error = new Error(
+          `Accessibility check failed for story "${storyId}" (${url}): ${cause?.message || cause}`,
+          { cause },
+        );
+        Object.assign(error, { storyId, url });
+        outcomes[index] = { storyId, url, status: 'failed', error };
+      }
+    }
+  };
+  // Pa11y releases its browsers before settling. Drain every worker before
+  // reporting or rejecting so the caller can safely close the Storybook server.
+  await Promise.all(
+    Array.from({ length: Math.min(concurrency, names.length) }, worker),
   );
-  const hasIssues = results.map(logReport).some(Boolean);
 
-  if (hasIssues) {
-    process.exit(1);
+  const failures = [];
+  let clean = 0;
+  let withFindings = 0;
+  for (const outcome of outcomes) {
+    if (outcome.status === 'failed') {
+      failures.push(outcome.error);
+      // Use the same output stream as completed reports to retain input order.
+      // Logging the original error object keeps its stack and nested causes.
+      console.log(
+        `Execution failed for story: ${outcome.storyId}\nURL: ${outcome.url}`,
+        outcome.error.cause,
+      );
+    } else if (logReport(outcome.report)) {
+      withFindings += 1;
+    } else {
+      clean += 1;
+    }
+  }
+  console.log(
+    `Accessibility summary: ${outcomes.length} attempted, ${clean} clean, ${withFindings} with findings, ${failures.length} failed to execute.`,
+  );
+
+  if ((withFindings || failures.length) && !process.exitCode) {
+    process.exitCode = 1;
+  }
+  if (failures.length) {
+    throw new AggregateError(
+      failures,
+      `Accessibility execution failed for ${failures.length} ${failures.length === 1 ? 'story' : 'stories'}.`,
+    );
   }
 };
 

package/scripts/audit/checks/twig-references.js

@@ -6,7 +6,7 @@ import { resolve } from 'node:path';
 import { makeFinding } from '../lib/findings.js';
 import { cachedReadFile } from '../lib/files.js';
 import {
-  findTwigIncludeSourceReferences,
+  findTwigReferenceCalls,
   findTwigNamespaceReferences,
   resolvesTwigReference,
 } from '../lib/twig.js';
@@ -23,6 +23,7 @@ export function auditTwigReferences(context) {
   const knownNamespaces = new Set([...Object.keys(namespaceRoots), 'assets']);
   const findings = [];
   const seen = new Set();
+  const componentGroupRootsCache = new Map();
 
   for (const twigFile of twigFiles) {
     const source = cachedReadFile(twigFile);
@@ -46,15 +47,25 @@ export function auditTwigReferences(context) {
       );
     }
 
-    for (const ref of findTwigIncludeSourceReferences(source)) {
-      if (!resolvesTwigReference(ref.value, twigFile, env)) {
+    for (const call of findTwigReferenceCalls(source)) {
+      // Optional or uncertain calls cannot establish a required missing target.
+      if (call.ignoreMissing !== false || call.hasDynamicCandidates) continue;
+      const resolved = call.candidates.some(
+        ({ value }) =>
+          value !== '' &&
+          resolvesTwigReference(value, twigFile, env, componentGroupRootsCache),
+      );
+      if (!resolved) {
+        const description = call.isFallbackArray
+          ? `fallback candidates ${JSON.stringify(call.candidates.map(({ value }) => value))}`
+          : `reference "${call.candidates[0].value}"`;
         findings.push(
           makeFinding({
             id: 'unresolved-twig-reference',
             severity: 'warn',
             filePath: twigFile,
-            line: ref.line,
-            message: `${ref.type}() reference "${ref.value}" could not be resolved from the normalized Twig roots.`,
+            line: call.line,
+            message: `${call.type}() ${description} could not be resolved from the normalized Twig roots.`,
             docs: 'https://github.com/emulsify-ds/emulsify-core/blob/4.x/docs/storybook.md#include',
           }),
         );