@deneb-ui/cli 2.0.51 → 2.0.53

package/bin/index.js

@@ -187,6 +187,18 @@ function detectPages(projectDir) {
               continue;
             }
             if (!foundRoutes.has('/' + routeName)) {
+              const pageFile = ['page.tsx', 'page.jsx', 'page.js']
+                .map((name) => path.join(cDir, routeName, name))
+                .find((file) => fs.existsSync(file));
+              const pagesFile = ['tsx', 'jsx', 'js']
+                .map((ext) => path.join(cDir, `${routeName}.${ext}`))
+                .find((file) => fs.existsSync(file));
+              if (!pageFile && !pagesFile && path.basename(cDir) !== 'pages' && path.basename(cDir) !== 'src') {
+                continue;
+              }
+              if (!pageFile && path.basename(cDir) !== 'pages' && !cDir.endsWith(`${path.sep}pages`)) {
+                continue;
+              }
               foundRoutes.add('/' + routeName);
               const label = routeName
                 .replace(/[-_]/g, ' ')

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@deneb-ui/cli",
-  "version": "2.0.51",
+  "version": "2.0.53",
   "description": "Official DENEB CLI — scaffold, convert, validate, and package Fivora-ready storefront templates.",
   "bin": {
     "deneb": "bin/index.js",
@@ -49,7 +49,7 @@
   "license": "MIT",
   "dependencies": {
     "@babel/parser": "^7.28.0",
-    "@deneb-ui/core": "^2.0.51",
+    "@deneb-ui/core": "^2.0.53",
     "@octokit/rest": "^22.0.1",
     "adm-zip": "^0.6.0",
     "dotenv": "^17.4.2",

package/src/arc/__tests__/arc.test.cjs

@@ -158,8 +158,8 @@ test('AST transformer preserves className and uses nullish fallbacks', () => {
   assert.match(result.code, /data-preview-field-path=/);
   assert.match(result.code, /\?\?/);
   assert.match(result.code, /<span[\s\S]*data-preview-field-path="/);
-  assert.match(result.code, /<span[^>]*hidden[^>]*data-preview-field-path="/);
-  assert.match(result.code, /data-preview-static="action-link"/);
+  assert.match(result.code, /<a\b[^>]*data-preview-field-path=/);
+  assert.doesNotMatch(result.code, /<span[^>]*hidden[^>]*data-preview-field-path/);
   assert.doesNotMatch(result.code, /'use client'/);
   assert.match(result.code, /site-data\.json|@\/data\/site-data\.json/);
   assert.match(result.code, /data-preview-style-target=/);
@@ -409,12 +409,14 @@ test('static-array collections become list contracts without changing render log
   assert.equal(siteData.content.home.products[0].title, 'Minimalist Smart Watch');
 });
 
-test('collections holding component references are left alone', () => {
+test('collections holding component references still bind primitive item fields', () => {
   const dir = copyOf(STOREFRONT_FIXTURE);
   silence(() => runDenebArc(dir, 'acme-store', { telemetry: 'off' }));
   const features = fs.readFileSync(path.join(dir, 'src', 'components', 'Features.tsx'), 'utf8');
-  assert.ok(!features.includes('data-preview-list-path'), 'icon component refs are not merchant content');
+  assert.match(features, /data-preview-list-path=/);
   assert.match(features, /icon: Truck/);
+  assert.match(features, /data-preview-static="component-ref"/);
+  assert.match(features, /data-preview-field-path=\{`[^`]*\.title`\}/);
 });
 
 test('literal text inside a broad container is wrapped instead of marked illegally', () => {
@@ -435,8 +437,8 @@ test('shadcn Button asChild keeps the action on the link and the label in a span
   assert.match(hero, /<Button asChild>/);
   assert.match(hero, /href=\{siteData\?\.content\?\.home\?\.hero\?\.shopCollectionUrl \?\? "\/products"\}/);
   assert.match(hero, /<span[\s\S]*data-preview-field-path="home\.hero\.shopCollectionLabel"/);
-  // The decorative icon stays static.
-  assert.match(hero, /<ArrowRight className="ml-2 size-4" aria-hidden="true" \/>/);
+  // The decorative icon stays static (may also receive data-preview-static).
+  assert.match(hero, /<ArrowRight[^>]*className="ml-2 size-4"[^>]*aria-hidden="true"/);
 });
 
 test('a second init run converges on identical sources and manifest', () => {
@@ -821,11 +823,12 @@ export function ActionPanel() {
   assert.match(result.code, /<a\s+[^>]*href=\{siteData\?\.content\?\.home\?\.hero\?\.whatsappUrl \?\? "https:\/\/wa\.me\/1234567890"\}/);
   assert.match(result.code, /target="_blank"/);
   assert.match(result.code, /rel="noopener noreferrer"/);
-  assert.match(result.code, /data-preview-static="action-link"/);
+  // URL field path is bound directly to outer <a> element (never hidden, never static conflict)
+  assert.match(result.code, /<a\s+[^>]*data-preview-field-path=\{?"home\.hero\.whatsappUrl"?\}/);
   // Text label wrapped in editable span
   assert.match(result.code, /<span\s+data-preview-field-path="home\.hero\.whatsappLabel"[^>]*>\{siteData\?\.content\?\.home\?\.hero\?\.whatsappLabel \?\? "Order on WhatsApp"\}<\/span>/);
-  // Hidden URL span present for Fivora contract
-  assert.match(result.code, /<span hidden aria-hidden="true" data-preview-field-path="home\.hero\.whatsappUrl">/);
+  // Never emit hidden preview markers
+  assert.doesNotMatch(result.code, /<span[^>]*hidden[^>]*data-preview-field-path/);
   // No parse errors
   assert.doesNotThrow(() => parseSource(result.code, 'ActionPanel.tsx'));
 });
@@ -1333,9 +1336,91 @@ export function ContactSection() {
   assert.ok(transformed.changed, 'file must be changed');
   assert.match(transformed.code, /data-preview-field-path/);
   assert.match(transformed.code, /formSubmitLabel/);
-  assert.match(transformed.code, /formWhatsappUrl/);
   assert.match(transformed.code, /type="submit"/);
-  assert.match(transformed.code, /hidden/);
+  assert.doesNotMatch(transformed.code, /<span[^>]*hidden/);
+  assert.doesNotMatch(transformed.code, /data-preview-static[\s\S]*data-preview-field-path/);
+});
+
+test('auditMarkerPlacement detects and rejects hidden preview markers', () => {
+  const hiddenCode = `
+    <div>
+      <span className="hidden" aria-hidden="true" data-preview-field-path="home.hero.buttonUrl">https://wa.me/123</span>
+      <span>Click me</span>
+    </div>
+  `;
+  const errors = contract.auditMarkerPlacement(hiddenCode, 'TestHidden.tsx');
+  assert.ok(errors.some((e) => e.includes('data-preview field/list/item marker is hidden')));
+});
+
+test('auditCoupledListMarkers detects and rejects coupling parallel list arrays by index', () => {
+  const coupledCode = `
+    <div data-preview-item-path="seasonal.items[0]">
+      <span data-preview-field-path="seasonal.preOrderCta[0].buttonLabel">Pre-Order</span>
+    </div>
+  `;
+  const errors = contract.auditCoupledListMarkers(coupledCode, 'TestCoupled.tsx');
+  assert.ok(errors.some((e) => e.includes('belongs to a different list')));
+});
+
+test('detectedPages without a page file are not invented in the manifest', () => {
+  const dir = copyOf(FIXTURE);
+  silence(() =>
+    runDenebArc(dir, 'basic-store', {
+      telemetry: 'off',
+      detectedPages: [{ id: 'contact', label: 'Contact', route: '/contact', required: true }],
+    })
+  );
+  const { manifest } = auditFivora(dir);
+  assert.ok(!manifest.pages.some((page) => page.id === 'contact' || page.route === '/contact'));
+});
+
+test('learning records contract failure instead of success', () => {
+  const { honestOutcome } = require('../learning.cjs');
+  assert.equal(
+    honestOutcome({ syntaxPassed: true, contractPassed: true, fivoraContractPassed: false }, 'success'),
+    'failure'
+  );
+  assert.equal(
+    honestOutcome({ syntaxPassed: true, contractPassed: true, fivoraContractPassed: true, uncoveredVisibleText: 0 }, 'success'),
+    'success'
+  );
+});
+
+test('residual pass marks leftover decorative copy static with a reason', () => {
+  const { applyResidualPass } = require('../residual.cjs');
+  const code = `export function Chrome() { return <button aria-hidden="true">Close</button>; }`;
+  const result = applyResidualPass({
+    code,
+    file: 'src/components/Chrome.tsx',
+    ownerScope: 'home',
+    usedPaths: new Set(),
+  });
+  assert.equal(result.changed, true);
+  assert.match(result.code, /data-preview-static="[^"]+"/);
+});
+
+test('style-bind grid and card attributes are written onto collection nodes', () => {
+  const dir = copyOf(STOREFRONT_FIXTURE);
+  silence(() => runDenebArc(dir, 'acme-store', { telemetry: 'off' }));
+  const grid = fs.readFileSync(path.join(dir, 'src', 'components', 'ProductGrid.tsx'), 'utf8');
+  assert.match(grid, /data-preview-style-type="grid"/);
+  assert.match(grid, /data-preview-style-type="card"/);
+  assert.match(grid, /data-preview-style-target="home\.products\.grid"/);
+});
+
+test('ContactActions stays mounted when all channels are empty', () => {
+  const sourcePath = path.join(__dirname, '..', '..', '..', '..', '..', 'packages', 'deneb-ui', 'src', 'contact', 'ContactActions.tsx');
+  const source = fs.readFileSync(sourcePath, 'utf8');
+  assert.doesNotMatch(source, /if \(!hasPhone && !hasWhatsApp && !hasEmail\)/);
+  assert.doesNotMatch(source, /return null/);
+});
+
+test('empty-state source audit flags gated preview markers', () => {
+  const errors = contract.auditEmptyStateSource(
+    '{title && <span data-preview-field-path="home.hero.title">{title}</span>}',
+    'Hero.tsx'
+  );
+  assert.ok(errors.some((error) => error.includes('gated behind')));
 });
 
 

package/src/arc/fivora-contract.cjs

@@ -8,6 +8,9 @@
  * locally rather than at upload time.
  */
 
+const recast = require('recast');
+const { parseSource, getJsxName, hasJsxAttribute, collectJsxText } = require('./ast.cjs');
+
 const MARKER_ATTRIBUTE_TO_KIND = {
   'data-preview-field-path': 'field',
   'data-preview-list-path': 'list',
@@ -214,6 +217,17 @@ function auditMarkerPlacement(code, filePath) {
     const staticMatch = attrs.match(/\bdata-preview-static\s*=\s*(?:"([^"]*)"|'([^']*)')/);
     const hasStatic = /\bdata-preview-static\b/.test(attrs);
 
+    const isHidden =
+      /\bhidden(?:[\s=]|\/?>)/i.test(attrs) ||
+      /\baria-hidden\s*=\s*(?:"true"|'true'|\{\s*true\s*\})/i.test(attrs) ||
+      /\bstyle\s*=\s*\{\s*\{[\s\S]*?\b(?:display\s*:\s*['"]none['"]|visibility\s*:\s*['"]hidden['"])[\s\S]*?\}\s*\}/i.test(attrs) ||
+      /\bclassName\s*=\s*(?:"[^"]*\bhidden\b[^"]*"|'[^']*\bhidden\b[^']*'|\{\s*`[^`]*\bhidden\b[^`]*`\s*\})/i.test(attrs);
+
+    if ((hasField || hasList || hasItem) && isHidden) {
+      errors.push(
+        `${filePath}:${line} data-preview field/list/item marker is hidden. Strict visual-edit targets must remain visible and clickable in the exported page.`
+      );
+    }
     if (hasStatic && !(staticMatch?.[1] ?? staticMatch?.[2] ?? '').trim()) {
       errors.push(`${filePath}:${line} data-preview-static requires a reason.`);
     }
@@ -234,6 +248,33 @@ function auditMarkerPlacement(code, filePath) {
     }
   }
 
+  errors.push(...auditCoupledListMarkers(code, filePath));
+  return errors;
+}
+
+/**
+ * Detects coupling parallel arrays by index: rendering a field from list B inside an item belonging to list A.
+ */
+function auditCoupledListMarkers(code, filePath) {
+  const errors = [];
+  const itemBlockPattern = /<\s*([a-zA-Z][a-zA-Z0-9.:-]*)((?:[^<>{}]|\{[^{}]*\})*?)\bdata-preview-item-path\s*=\s*(?:"([^"]*)"|'([^']*)'|\{\s*`([^`]*)`\s*\})([\s\S]*?)<\/\1>/g;
+  for (const match of String(code).matchAll(itemBlockPattern)) {
+    const itemPath = match[3] ?? match[4] ?? match[5] ?? '';
+    const inner = match[6] || '';
+    if (!itemPath) continue;
+    const baseList = itemPath.replace(/\[[^\]]*\]$/, '');
+
+    for (const fieldMatch of inner.matchAll(/\bdata-preview-field-path\s*=\s*(?:"([^"]*)"|'([^']*)'|\{\s*`([^`]*)`\s*\})/g)) {
+      const fieldPath = fieldMatch[1] ?? fieldMatch[2] ?? fieldMatch[3] ?? '';
+      if (!fieldPath || !/\[\d+\]/.test(fieldPath)) continue;
+      const fieldList = fieldPath.replace(/\[\d+\][\s\S]*$/, '');
+      if (fieldList && baseList && fieldList !== baseList) {
+        errors.push(
+          `${filePath}:${lineNumberAt(code, match.index ?? 0)} repeated field "${fieldPath}" is rendered inside item "${itemPath}" but belongs to a different list. Model one visual card as one object-list item instead of coupling parallel arrays by index.`
+        );
+      }
+    }
+  }
   return errors;
 }
 
@@ -475,8 +516,71 @@ function auditPreviewRuntime(sources) {
 /**
  * Finds meaningful visible JSX text that is neither bound to a field nor marked
  * static. Strict mode treats these as errors in the exported HTML.
+ * Prefers an AST walk so TypeScript generics and nested tags are not misread.
  */
 function findUncoveredVisibleText(code, filePath) {
+  let ast;
+  try {
+    ast = parseSource(code, filePath);
+  } catch {
+    return findUncoveredVisibleTextRegex(code, filePath);
+  }
+
+  const findings = [];
+  recast.types.visit(ast, {
+    visitJSXElement(pathNode) {
+      const node = pathNode.node;
+      const tag = getJsxName(node);
+      const lower = String(tag || '').toLowerCase();
+      if (!tag || lower === 'option' || lower === 'script' || lower === 'style') {
+        this.traverse(pathNode);
+        return;
+      }
+      if (
+        hasJsxAttribute(node, 'data-preview-field-path') ||
+        hasJsxAttribute(node, 'data-preview-static')
+      ) {
+        this.traverse(pathNode);
+        return;
+      }
+      if (ancestorHasStaticMarker(pathNode)) {
+        this.traverse(pathNode);
+        return;
+      }
+      const text = collectJsxText(node);
+      if (isMeaningfulUncoveredText(text)) {
+        findings.push({
+          tag,
+          text,
+          filePath,
+          line: node.loc?.start?.line || 1,
+        });
+      }
+      this.traverse(pathNode);
+    },
+  });
+  return findings;
+}
+
+function ancestorHasStaticMarker(pathNode) {
+  let current = pathNode.parent;
+  while (current) {
+    const node = current.node || current.value;
+    if (node && node.type === 'JSXElement' && hasJsxAttribute(node, 'data-preview-static')) return true;
+    current = current.parentPath || current.parent;
+  }
+  return false;
+}
+
+function isMeaningfulUncoveredText(text) {
+  const value = String(text || '').replace(/\s+/g, ' ').trim();
+  if (!value || value.length <= 2 || !/\p{L}/u.test(value)) return false;
+  if (!/^[\p{L}\p{N}"'(¡¿#$€£]/u.test(value)) return false;
+  if (/^(?:true|false|null|undefined)$/i.test(value)) return false;
+  return true;
+}
+
+function findUncoveredVisibleTextRegex(code, filePath) {
   const findings = [];
   const source = String(code);
   const elementPattern = /<\s*([a-zA-Z][a-zA-Z0-9.:-]*)((?:[^<>{}]|\{[^{}]*\})*?)>([^<>{}]*)</g;
@@ -487,13 +591,9 @@ function findUncoveredVisibleText(code, filePath) {
     const text = (match[3] || '').replace(/\s+/g, ' ').trim();
     const offset = match.index ?? 0;
 
-    // A `<` preceded by an identifier character is a TypeScript generic
-    // (forwardRef<HTMLButtonElement, Props>), never a JSX element.
     if (/[\w$)\]]/.test(source[offset - 1] || '')) continue;
     if (tag.toLowerCase() === 'option') continue;
-    if (!text || text.length <= 2 || !/\p{L}/u.test(text)) continue;
-    if (!/^[\p{L}\p{N}"'(¡¿#$€£]/u.test(text)) continue;
-    if (/^(?:true|false|null|undefined)$/i.test(text)) continue;
+    if (!isMeaningfulUncoveredText(text)) continue;
     if (/\bdata-preview-(?:field-path|static)\b/.test(attrs)) continue;
 
     findings.push({ tag, text, filePath, line: lineNumberAt(source, offset) });
@@ -502,6 +602,161 @@ function findUncoveredVisibleText(code, filePath) {
   return findings;
 }
 
+function auditEmptyStateSource(code, filePath) {
+  const errors = [];
+  const source = String(code);
+  const andPattern =
+    /\{([^{}]{0,120}?)\s*&&\s*\(?\s*<\s*([a-zA-Z][\w.:-]*)([^>]*data-preview-(?:field-path|list-path|item-path)[^>]*)>/g;
+  for (const match of source.matchAll(andPattern)) {
+    errors.push(
+      `${filePath}:${lineNumberAt(source, match.index ?? 0)} editable marker is gated behind "${String(match[1]).trim()} &&". Keep the target mounted when its value is empty, false, or zero.`
+    );
+  }
+  const ternaryPattern =
+    /\{([^{}]{0,80}?)\s*\?\s*<\s*([a-zA-Z][\w.:-]*)([^>]*data-preview-(?:field-path|list-path|item-path)[^>]*)>[\s\S]{0,200}?\?\s*(?:null|false|undefined)/g;
+  for (const match of source.matchAll(ternaryPattern)) {
+    errors.push(
+      `${filePath}:${lineNumberAt(source, match.index ?? 0)} editable marker unmounts on a falsy ternary. Keep the target mounted when its value is empty.`
+    );
+  }
+  return errors;
+}
+
+function auditSelectOptions(editorSchema, pages = []) {
+  const errors = [];
+  const declaredPageIds = new Set((pages || []).map((page) => page?.id).filter(Boolean));
+
+  function checkSelect(path, options) {
+    if (!Array.isArray(options) || !options.some((option) => typeof option === 'string' && option.trim())) {
+      errors.push(
+        `editorSchema select field "${path}" must declare at least one non-empty option for strict visual editing.`
+      );
+      return;
+    }
+    if (!declaredPageIds.size) return;
+    if (!/(?:destination|action|targetpage|buttonaction|pagekey)/i.test(path)) return;
+    for (const option of options) {
+      const opt = typeof option === 'string' ? option.trim() : '';
+      if (opt && opt !== 'none' && opt !== 'external' && !declaredPageIds.has(opt)) {
+        errors.push(
+          `editorSchema select field "${path}" declares destination option "${opt}" which is not in fivora-template.json pages[].`
+        );
+      }
+    }
+  }
+
+  function walk(path, node) {
+    if (!node) return;
+    if (node.type === 'select') {
+      checkSelect(path, node.options);
+      return;
+    }
+    if (node.type === 'object') {
+      for (const field of node.fields || []) walk(appendPath(path, field.key), field);
+      return;
+    }
+    if (node.type !== 'list') return;
+    const itemPath = `${wildcardPath(path)}[*]`;
+    if (node.itemField?.type === 'select') checkSelect(itemPath, node.itemField.options);
+    for (const field of node.fields || []) walk(appendPath(itemPath, field.key), field);
+  }
+
+  for (const section of editorSchema?.sections || []) walk(section.path, section);
+  return errors;
+}
+
+function auditListBounds(editorSchema, content) {
+  const errors = [];
+
+  function validBound(value) {
+    return typeof value === 'number' && Number.isSafeInteger(value) && value >= 0 ? value : null;
+  }
+
+  function readValue(path) {
+    let value = content || {};
+    for (const part of String(path).split('.')) {
+      if (!part || !isPlainObject(value)) return undefined;
+      value = value[part];
+    }
+    return value;
+  }
+
+  function walkSchema(path, node) {
+    if (!node) return;
+    if (node.type === 'object') {
+      for (const field of node.fields || []) walkSchema(appendPath(path, field.key), field);
+      return;
+    }
+    if (node.type !== 'list') return;
+    const minItems = validBound(node.minItems);
+    const maxItems = validBound(node.maxItems);
+    if (node.minItems !== undefined && minItems === null) {
+      errors.push(`editorSchema list "${path}" minItems must be a non-negative safe integer.`);
+    }
+    if (node.maxItems !== undefined && maxItems === null) {
+      errors.push(`editorSchema list "${path}" maxItems must be a non-negative safe integer.`);
+    }
+    const effectiveMinimum = minItems ?? (node.required ? 1 : 0);
+    if (maxItems !== null && effectiveMinimum > maxItems) {
+      errors.push(
+        `editorSchema list "${path}" requires at least ${effectiveMinimum} item(s) but maxItems is ${maxItems}.`
+      );
+    }
+    const items = Array.isArray(readValue(path)) ? readValue(path) : [];
+    if (maxItems !== null && items.length > maxItems) {
+      errors.push(
+        `site-data.json content list "${path}" contains ${items.length} items, exceeding editorSchema maxItems ${maxItems}.`
+      );
+    }
+    const itemPath = `${wildcardPath(path)}[*]`;
+    for (const field of node.fields || []) walkSchema(appendPath(itemPath, field.key), field);
+  }
+
+  for (const section of editorSchema?.sections || []) walkSchema(section.path, section);
+  return errors;
+}
+
+function auditStaticMarkerAuthorship(code, filePath) {
+  if (!/\.[cm]?[jt]s$/i.test(filePath) || /\.(tsx|jsx)$/i.test(filePath)) return [];
+  const mutation =
+    /\b(?:setAttribute|setAttributeNS|toggleAttribute)\s*\(\s*['"`]data-preview-static['"`]/.exec(code) ||
+    /\b(?:writeFile|writeFileSync)\s*\([\s\S]{0,200}data-preview-static/.exec(code);
+  if (!mutation) return [];
+  return [
+    `${filePath}:${lineNumberAt(code, mutation.index || 0)} programmatically injects data-preview-static. Author each intentional static annotation directly on the smallest source element.`,
+  ];
+}
+
+function auditRouteOwnedMarkerCoverage({ editorSchema, pages, markers, controlOnlyPaths }) {
+  const errors = [];
+  const pagesById = new Map((pages || []).map((page) => [page.id, page]));
+  const sections = (editorSchema?.sections || [])
+    .map((section) => ({ section, canonicalPath: canonicalizeMarkerPath(section.path) }))
+    .filter((entry) => entry.canonicalPath);
+
+  for (const marker of markers || []) {
+    if (marker.kind === 'page' || marker.kind === 'item') continue;
+    const canonical = canonicalizeMarkerPath(marker.value);
+    if (!canonical) continue;
+    if (marker.kind === 'field' && isControlOnly(canonical, controlOnlyPaths)) continue;
+    const owner = sections
+      .filter((entry) => {
+        const sectionPath = wildcardPath(entry.canonicalPath);
+        const markerPath = wildcardPath(canonical);
+        return markerPath === sectionPath || markerPath.startsWith(`${sectionPath}.`) || markerPath.startsWith(`${sectionPath}[`);
+      })
+      .sort((left, right) => right.canonicalPath.length - left.canonicalPath.length)[0];
+    if (!owner?.section.pageKey) continue;
+    const page = pagesById.get(owner.section.pageKey);
+    if (!page) {
+      errors.push(
+        `editorSchema section "${owner.section.path}" assigns ${marker.kind} "${canonical}" to unknown manifest page "${owner.section.pageKey}".`
+      );
+    }
+  }
+  return errors;
+}
+
 module.exports = {
   BROAD_CONTENT_CONTAINERS,
   PRIMITIVE_TYPES,
@@ -509,11 +764,17 @@ module.exports = {
   enumerateSchemaPaths,
   extractMarkers,
   auditMarkerPlacement,
+  auditCoupledListMarkers,
   auditActionLabelCollision,
   auditPathCoverage,
   auditSchemaUniqueness,
   auditPageCoverage,
   auditPreviewRuntime,
+  auditEmptyStateSource,
+  auditSelectOptions,
+  auditListBounds,
+  auditStaticMarkerAuthorship,
+  auditRouteOwnedMarkerCoverage,
   findUncoveredVisibleText,
   canonicalizeMarkerPath,
   wildcardPath,