dslinter 0.1.13 → 0.2.2

package/src/types/playground.ts

@@ -1,3 +1,4 @@
+import type { ReactNode } from "react";
 import type { PlaygroundArgs, PlaygroundControl } from "./controls";
 import type { PlaygroundPreviewComponent } from "./preview";
 
@@ -17,5 +18,8 @@ export type PlaygroundEntry = {
   controls: PlaygroundControl[];
   /** Optional JSX-ish snippet from current `values` (consumer-defined). */
   usageSnippet?: (values: PlaygroundArgs) => string;
+  /** Render live preview from control values (preferred — avoids unstable component types). */
+  renderPreview: (values: PlaygroundArgs) => ReactNode;
+  /** @deprecated Use `renderPreview` — kept for manual `definePlayground` call sites. */
   Preview: PlaygroundPreviewComponent;
 };

package/src/types/report.ts

@@ -17,6 +17,11 @@ export interface ComponentDefinition {
   line: number;
   /** Props destructured from the first parameter, when detectable. */
   declared_props?: string[];
+  /** CVA variant option keys per prop (playground select controls). */
+  declared_prop_options?: Record<string, string[]>;
+  /** Default values from CVA `defaultVariants`. */
+  declared_prop_defaults?: Record<string, string>;
+  cva_binding_name?: string;
 }
 
 export interface JsxUsage {
@@ -33,6 +38,8 @@ export interface LintFinding {
   path: string;
   line: number | null;
   severity: Severity;
+  /** Prop combo label from CVA matrix scan (CI or playground). */
+  variant_label?: string;
 }
 
 export interface FileScan {
@@ -78,12 +85,6 @@ export interface UsageSummary {
   usage_locations?: UsageLocation[];
 }
 
-export interface OwnershipSummary {
-  owner: string;
-  files: number;
-  definitions: number;
-}
-
 /**
  * Simplified prop kind from TypeScript (e.g. demo `merge-playgrounds.mjs`).
  * Dashboard falls back to name heuristics when a key is missing or kind is `unknown`.
@@ -98,10 +99,14 @@ export interface PlaygroundSpec {
   declared_props: string[];
   group?: string | null;
   /**
-   * Optional map from prop name to simplified TS kind, filled by tooling that runs the TS checker
-   * (demo: `merge-playgrounds.mjs`). Omitted when empty or unavailable.
+   * Optional map from prop name to simplified TS kind, filled by the TS enrich step
+   * after scanning (`bin/lib/enrich-playgrounds-from-ts.mjs`). Omitted when empty or unavailable.
    */
   declared_prop_kinds?: Partial<Record<string, DeclaredPropKind>>;
+  /** CVA variant option keys per prop (dashboard renders as `<Select>`). */
+  declared_prop_options?: Record<string, string[]>;
+  /** Default values from CVA `defaultVariants`. */
+  declared_prop_defaults?: Record<string, string>;
 }
 
 export type CssTokenCategory =
@@ -136,14 +141,32 @@ export interface CssTokenSummary {
   unused_tokens?: string[];
 }
 
+/** Dashboard-relevant slice of `.dslinter.json` embedded in each scan report. */
+export interface ReportConfig {
+  hidden_components?: string[];
+  hidden_paths?: string[];
+}
+
+/** Agent/MCP-friendly slice of `.dslinter.json` embedded in each scan report. */
+export interface ConfigSnapshot {
+  deprecated_components?: string[];
+  known_tokens?: string[];
+  include_dirs?: string[];
+}
+
 export interface WorkspaceReport {
+  /** Report JSON schema version (1+). Omitted in legacy reports. */
+  schema_version?: number;
+  /** ISO 8601 UTC timestamp when the report was generated. */
+  generated_at?: string;
   root: string;
   files: FileScan[];
   findings: LintFinding[];
   duplicate_components: DuplicateComponent[];
   usage_by_component: UsageSummary[];
-  ownership: OwnershipSummary[];
   scores: GovernanceScores;
   playgrounds?: PlaygroundSpec[];
   css_tokens?: CssTokenSummary;
+  config?: ReportConfig;
+  config_snapshot?: ConfigSnapshot;
 }

package/templates/playground/buildRegistry.ts

@@ -2,7 +2,7 @@ import type { PlaygroundEntry, WorkspaceReport } from "dslinter";
 import { createPlaygroundRegistry } from "dslinter";
 
 /**
- * Eager Vite glob — must cover every path in `dslint-report.json` → `playgrounds[].rel_path`.
+ * Eager Vite glob — must cover every path in `dslinter-report.json` → `playgrounds[].rel_path`.
  * Nested paths (e.g. `src/components/ui/button.tsx`) require `**`, not a single `*`.
  */
 const modules = import.meta.glob("../components/**/*.{tsx,jsx}", {

package/templates/vite.dslinter.snippet.ts

@@ -2,7 +2,18 @@
  * Legacy snippet — prefer `import dslinter from "dslinter/vite"` (one plugin line).
  * `npx dslinter` merges the plugin automatically when a consumer Vite app exists.
  */
-const DSLINT_SERVE_PORT = Number(process.env.DSLINT_SERVE_PORT ?? "7878");
+function resolveServePort(): number {
+  const rawPort = process.env.DSLINTER_SERVE_PORT ?? process.env.PORT;
+  const parsedPort = Number(rawPort);
+
+  if (Number.isInteger(parsedPort) && parsedPort > 0) {
+    return parsedPort;
+  }
+
+  return 3210;
+}
+
+const DSLINTER_SERVE_PORT = resolveServePort();
 
 export const dslinterViteSnippet = {
   resolve: {
@@ -13,12 +24,12 @@ export const dslinterViteSnippet = {
   },
   server: {
     proxy: {
-      "/dslint-report.json": {
-        target: `http://127.0.0.1:${DSLINT_SERVE_PORT}`,
+      "/dslinter-report.json": {
+        target: `http://127.0.0.1:${DSLINTER_SERVE_PORT}`,
         changeOrigin: true,
       },
       "/events": {
-        target: `http://127.0.0.1:${DSLINT_SERVE_PORT}`,
+        target: `http://127.0.0.1:${DSLINTER_SERVE_PORT}`,
         changeOrigin: true,
       },
     },

package/vite/collectScanModules.test.ts

@@ -8,23 +8,26 @@ import {
 } from "./collectScanModules";
 
 describe("embedGlobKeyFromRelPath", () => {
-  it("maps Laravel rel_path to @dslint-scan key", () => {
+  it("maps Laravel rel_path to @dslinter-scan key", () => {
     expect(
       embedGlobKeyFromRelPath(
         "resources/js/Components/Billing/AdditionalEventLimitModal.tsx",
       ),
     ).toBe(
-      "@dslint-scan/resources/js/Components/Billing/AdditionalEventLimitModal.tsx",
+      "@dslinter-scan/resources/js/Components/Billing/AdditionalEventLimitModal.tsx",
     );
   });
 
   it("strips leading slashes", () => {
     expect(embedGlobKeyFromRelPath("/src/components/Foo.tsx")).toBe(
-      "@dslint-scan/src/components/Foo.tsx",
+      "@dslinter-scan/src/components/Foo.tsx",
     );
   });
 });
 
+const caseInsensitiveFs =
+  process.platform === "darwin" || process.platform === "win32";
+
 describe("collectScanModuleRelPaths", () => {
   it("collects tsx/jsx and skips node_modules", () => {
     const root = mkdtempSync(join(tmpdir(), "dslinter-scan-"));
@@ -39,4 +42,89 @@ describe("collectScanModuleRelPaths", () => {
     const paths = collectScanModuleRelPaths(root);
     expect(paths).toEqual(["resources/js/Components/Button.tsx"]);
   });
+
+  it("respects .dslinter.json include_dirs", () => {
+    const root = mkdtempSync(join(tmpdir(), "dslinter-scan-inc-"));
+    mkdirSync(join(root, "resources", "js", "components", "ui"), {
+      recursive: true,
+    });
+    mkdirSync(join(root, "resources", "js", "pages"), { recursive: true });
+    writeFileSync(
+      join(root, "resources", "js", "components", "ui", "button.tsx"),
+      "export function Button() { return null; }",
+    );
+    writeFileSync(
+      join(root, "resources", "js", "pages", "Home.tsx"),
+      "export default function Home() { return null; }",
+    );
+    writeFileSync(
+      join(root, ".dslinter.json"),
+      JSON.stringify({ include_dirs: ["resources/js/components"] }),
+    );
+
+    const paths = collectScanModuleRelPaths(root);
+    expect(paths).toEqual(["resources/js/components/ui/button.tsx"]);
+  });
+
+  it.skipIf(!caseInsensitiveFs)(
+    "matches include_dirs case-insensitively on case-insensitive filesystems",
+    () => {
+      const root = mkdtempSync(join(tmpdir(), "dslinter-scan-case-"));
+      mkdirSync(join(root, "resources", "js", "Components"), { recursive: true });
+      writeFileSync(
+        join(root, "resources", "js", "Components", "Button.tsx"),
+        "export function Button() { return null; }",
+      );
+      writeFileSync(
+        join(root, ".dslinter.json"),
+        JSON.stringify({ include_dirs: ["resources/js/components"] }),
+      );
+
+      const paths = collectScanModuleRelPaths(root);
+      expect(paths).toEqual(["resources/js/Components/Button.tsx"]);
+    },
+  );
+
+  it.skipIf(caseInsensitiveFs)(
+    "requires include_dirs casing to match on case-sensitive filesystems",
+    () => {
+      const root = mkdtempSync(join(tmpdir(), "dslinter-scan-case-"));
+      mkdirSync(join(root, "resources", "js", "Components"), { recursive: true });
+      writeFileSync(
+        join(root, "resources", "js", "Components", "Button.tsx"),
+        "export function Button() { return null; }",
+      );
+      writeFileSync(
+        join(root, ".dslinter.json"),
+        JSON.stringify({ include_dirs: ["resources/js/components"] }),
+      );
+
+      expect(collectScanModuleRelPaths(root)).toEqual([]);
+    },
+  );
+
+  it("scopes collection to scanRoot subdirectory", () => {
+    const root = mkdtempSync(join(tmpdir(), "dslinter-scan-sub-"));
+    mkdirSync(join(root, "resources", "js", "components"), { recursive: true });
+    mkdirSync(join(root, "resources", "js", "layouts", "auth"), {
+      recursive: true,
+    });
+    writeFileSync(
+      join(root, "resources", "js", "components", "Button.tsx"),
+      "export function Button() { return null; }",
+    );
+    writeFileSync(
+      join(root, "resources", "js", "layouts", "auth", "Split.tsx"),
+      "export function Split() { return null; }",
+    );
+    writeFileSync(
+      join(root, ".dslinter.json"),
+      JSON.stringify({ include_dirs: ["resources/js"] }),
+    );
+
+    const paths = collectScanModuleRelPaths(
+      join(root, "resources", "js", "components"),
+    );
+    expect(paths).toEqual(["resources/js/components/Button.tsx"]);
+  });
 });

package/vite/collectScanModules.ts

@@ -1,5 +1,8 @@
-import { readdirSync } from "node:fs";
-import { join, relative, resolve } from "node:path";
+import { existsSync, readFileSync, readdirSync } from "node:fs";
+import { dirname, join, relative, resolve } from "node:path";
+import { embedGlobKeyFromRelPath } from "../src/playground/embedGlobKey";
+
+const CONFIG_NAMES = [".dslinter.json", "dslinter.json"];
 
 const SKIP_DIR_NAMES = new Set([
   "node_modules",
@@ -20,41 +23,103 @@ const SKIP_DIR_NAMES = new Set([
 
 const SOURCE_EXT = /\.(tsx|jsx)$/;
 
+function findConfigPath(startDir: string): string | null {
+  let dir = resolve(startDir);
+  for (;;) {
+    for (const name of CONFIG_NAMES) {
+      const candidate = join(dir, name);
+      if (existsSync(candidate)) return candidate;
+    }
+    const parent = dirname(dir);
+    if (parent === dir) break;
+    dir = parent;
+  }
+  return null;
+}
+
+export function projectRootForConfig(startDir: string): string {
+  const configPath = findConfigPath(startDir);
+  return configPath ? dirname(configPath) : resolve(startDir);
+}
+
+export function readIncludeDirs(projectRoot: string): string[] | null {
+  const configPath = findConfigPath(projectRoot);
+  if (!configPath) return null;
+  try {
+    const parsed = JSON.parse(readFileSync(configPath, "utf8")) as {
+      include_dirs?: string[];
+    };
+    if (Array.isArray(parsed.include_dirs) && parsed.include_dirs.length > 0) {
+      return parsed.include_dirs;
+    }
+  } catch {
+    return null;
+  }
+  return null;
+}
+
+function pathMatchesIncludePrefix(relFromProject: string, prefix: string): boolean {
+  const norm = prefix.trim().replace(/\\/g, "/").replace(/\/$/, "");
+  if (!norm) return false;
+  if (process.platform === "darwin" || process.platform === "win32") {
+    const rel = relFromProject.toLowerCase();
+    const pref = norm.toLowerCase();
+    return rel === pref || rel.startsWith(`${pref}/`);
+  }
+  return relFromProject === norm || relFromProject.startsWith(`${norm}/`);
+}
+
+function matchesIncludeDirs(
+  relFromProject: string,
+  includeDirs: string[] | null,
+): boolean {
+  if (!includeDirs) return true;
+  return includeDirs.some((dir) =>
+    pathMatchesIncludePrefix(relFromProject, dir),
+  );
+}
+
+function walkDir(
+  dir: string,
+  projectRoot: string,
+  includeDirs: string[] | null,
+  out: string[],
+): void {
+  let entries;
+  try {
+    entries = readdirSync(dir, { withFileTypes: true });
+  } catch {
+    return;
+  }
+  for (const ent of entries) {
+    if (ent.name.startsWith(".") && ent.name !== ".") continue;
+    const full = join(dir, ent.name);
+    if (ent.isDirectory()) {
+      if (SKIP_DIR_NAMES.has(ent.name)) continue;
+      walkDir(full, projectRoot, includeDirs, out);
+    } else if (ent.isFile() && SOURCE_EXT.test(ent.name)) {
+      const relFromProject = relative(projectRoot, full).replace(/\\/g, "/");
+      if (!matchesIncludeDirs(relFromProject, includeDirs)) continue;
+      out.push(relFromProject);
+    }
+  }
+}
+
 /**
  * Collect repo-relative posix paths for `.tsx`/`.jsx` files under `scanRoot`.
+ * Config and `include_dirs` resolve from the nearest project root; only files
+ * under `scanRoot` are walked.
  */
 export function collectScanModuleRelPaths(scanRoot: string): string[] {
-  const root = resolve(scanRoot);
+  const scanAbs = resolve(scanRoot);
+  const projectRoot = projectRootForConfig(scanAbs);
+  const includeDirs = readIncludeDirs(projectRoot);
   const out: string[] = [];
 
-  function walk(dir: string): void {
-    let entries;
-    try {
-      entries = readdirSync(dir, { withFileTypes: true });
-    } catch {
-      return;
-    }
-    for (const ent of entries) {
-      if (ent.name.startsWith(".") && ent.name !== ".") continue;
-      const full = join(dir, ent.name);
-      if (ent.isDirectory()) {
-        if (SKIP_DIR_NAMES.has(ent.name)) continue;
-        walk(full);
-      } else if (ent.isFile() && SOURCE_EXT.test(ent.name)) {
-        out.push(relative(root, full).replace(/\\/g, "/"));
-      }
-    }
-  }
+  walkDir(scanAbs, projectRoot, includeDirs, out);
 
-  walk(root);
   out.sort();
   return out;
 }
 
-/**
- * Virtual module map key for a scanner `rel_path` (embed convention).
- */
-export function embedGlobKeyFromRelPath(relPath: string): string {
-  const trimmed = relPath.replace(/^\/+/, "");
-  return `@dslint-scan/${trimmed}`;
-}
+export { embedGlobKeyFromRelPath };

package/vite/consumer.config.mjs

@@ -2,10 +2,10 @@ import { defineConfig, loadConfigFromFile, mergeConfig } from "vite";
 
 /**
  * Merges the consumer's vite.config with the dslinter plugin.
- * Used by `npx dslinter` when a host Vite app is detected (`DSLINT_VITE_ROOT`).
+ * Used by `npx dslinter` when a host Vite app is detected (`DSLINTER_VITE_ROOT`).
  */
 export default defineConfig(async ({ command, mode }) => {
-  const viteRoot = process.env.DSLINT_VITE_ROOT?.trim() || process.cwd();
+  const viteRoot = process.env.DSLINTER_VITE_ROOT?.trim() || process.cwd();
   const loaded = await loadConfigFromFile(
     { command, mode },
     undefined,
@@ -13,10 +13,13 @@ export default defineConfig(async ({ command, mode }) => {
   );
   const userConfig = loaded?.config ?? {};
   const { default: dslinter } = await import("./plugin.ts");
+  const scanRoot = process.env.DSLINTER_SCAN_ROOT?.trim() || viteRoot;
+  const consumerViteRoot =
+    process.env.DSLINTER_CONSUMER_VITE_ROOT?.trim() || viteRoot;
   return mergeConfig(
     userConfig,
     defineConfig({
-      plugins: [dslinter()],
+      plugins: [dslinter({ scanRoot, consumerViteRoot })],
     }),
   );
 });

package/vite/consumerAlias.test.ts

@@ -0,0 +1,47 @@
+import { describe, expect, it } from "vitest";
+import {
+  flattenViteAlias,
+  importerUnderScanRoot,
+  resolveWithConsumerAliases,
+} from "./consumerAlias";
+
+describe("flattenViteAlias", () => {
+  it("resolves @/ prefix from record alias", () => {
+    const aliases = flattenViteAlias(
+      { "@": "/app/resources/js", "@/": "/app/resources/js/" },
+      "/app",
+    );
+    const resolved = resolveWithConsumerAliases(
+      "@/Components/Button",
+      aliases,
+    );
+    expect(resolved?.replace(/\\/g, "/")).toContain("resources/js");
+    expect(resolved?.replace(/\\/g, "/")).toContain("Components/Button");
+  });
+});
+
+describe("importerUnderScanRoot", () => {
+  it("matches files under scan root", () => {
+    expect(
+      importerUnderScanRoot(
+        "/repo/resources/js/Components/Foo.tsx",
+        "/repo",
+      ),
+    ).toBe(true);
+    expect(
+      importerUnderScanRoot(
+        "/other/pkg/Button.tsx",
+        "/repo",
+      ),
+    ).toBe(false);
+  });
+
+  it("matches paths with Vite query suffixes", () => {
+    expect(
+      importerUnderScanRoot(
+        "/repo/resources/js/hooks/use-current-url.ts?v=abc",
+        "/repo",
+      ),
+    ).toBe(true);
+  });
+});

package/vite/consumerAlias.ts

@@ -0,0 +1,114 @@
+import { isAbsolute, join, resolve } from "node:path";
+import type { Alias, AliasOptions } from "vite";
+
+export type FlatAlias = {
+  find: string | RegExp;
+  replacement: string;
+};
+
+function normalizeFind(find: string | RegExp): string | RegExp {
+  if (typeof find !== "string") return find;
+  if (find.endsWith("/") && !find.includes("*")) {
+    return find.slice(0, -1);
+  }
+  return find;
+}
+
+/**
+ * Flatten Vite `resolve.alias` for use in a custom resolveId hook.
+ */
+export function flattenViteAlias(
+  alias: AliasOptions | undefined,
+  consumerRoot: string,
+): FlatAlias[] {
+  if (!alias) return [];
+  const root = resolve(consumerRoot);
+  const out: FlatAlias[] = [];
+
+  const push = (find: string | RegExp, replacement: string) => {
+    const rep = isAbsolute(replacement)
+      ? replacement
+      : resolve(root, replacement);
+    out.push({ find: normalizeFind(find), replacement: rep });
+  };
+
+  if (Array.isArray(alias)) {
+    for (const entry of alias) {
+      if (typeof entry === "object" && entry !== null && "find" in entry) {
+        const e = entry as Alias;
+        push(e.find, String(e.replacement));
+      }
+    }
+    return out.sort((a, b) => {
+      const al = typeof a.find === "string" ? a.find.length : 0;
+      const bl = typeof b.find === "string" ? b.find.length : 0;
+      return bl - al;
+    });
+  }
+
+  for (const [find, replacement] of Object.entries(alias)) {
+    push(find, String(replacement));
+  }
+  return out.sort((a, b) => {
+    const al = typeof a.find === "string" ? a.find.length : 0;
+    const bl = typeof b.find === "string" ? b.find.length : 0;
+    return bl - al;
+  });
+}
+
+/**
+ * Resolve `id` using consumer aliases (longest prefix first for strings).
+ */
+export function resolveWithConsumerAliases(
+  id: string,
+  aliases: FlatAlias[],
+): string | null {
+  for (const { find, replacement } of aliases) {
+    if (typeof find === "string") {
+      if (find.endsWith("/")) {
+        if (id.startsWith(find)) {
+          const sub = id.slice(find.length);
+          return join(replacement, sub);
+        }
+        const findNoSlash = find.slice(0, -1);
+        if (id === findNoSlash || id.startsWith(`${findNoSlash}/`)) {
+          const sub = id === findNoSlash ? "" : id.slice(findNoSlash.length + 1);
+          return sub ? join(replacement, sub) : replacement;
+        }
+      } else if (id === find) {
+        return replacement;
+      } else if (id.startsWith(`${find}/`)) {
+        const sub = id.slice(find.length + 1);
+        return join(replacement, sub);
+      }
+    } else {
+      const m = id.match(find);
+      if (m) {
+        return id.replace(find, replacement);
+      }
+    }
+  }
+  return null;
+}
+
+/** True when `importer` is a file under `scanRoot`. */
+export function importerUnderScanRoot(
+  importer: string | undefined,
+  scanRoot: string,
+): boolean {
+  if (!importer || importer === "\0virtual") return false;
+  const root = resolve(scanRoot).replace(/\\/g, "/");
+  let norm = importer.replace(/\\/g, "/");
+  if (norm.startsWith("\0")) norm = norm.slice(1);
+  const q = norm.indexOf("?");
+  if (q !== -1) norm = norm.slice(0, q);
+  const rootWithSlash = root.endsWith("/") ? root : `${root}/`;
+  return norm === root || norm.startsWith(rootWithSlash);
+}
+
+export const INERTIA_SHIM_IDS = new Set([
+  "@inertiajs/react",
+  "@inertiajs/react/server",
+]);
+
+export const ZIGGY_SHIM_ID = "ziggy-js";

package/vite/embedTailwindSources.test.ts

@@ -0,0 +1,74 @@
+import { mkdirSync, writeFileSync } from "node:fs";
+import { join, resolve } from "node:path";
+import { tmpdir } from "node:os";
+import { mkdtempSync } from "node:fs";
+import { describe, expect, it } from "vitest";
+import {
+  buildEmbedIndexCss,
+  embedSourcePathsRelativeToCss,
+  resolveEmbedConsumerSourceDirs,
+  shouldInjectEmbedConsumerSources,
+} from "./embedTailwindSources";
+
+const packageRoot = resolve(import.meta.dirname, "..");
+const embedCssPath = join(packageRoot, "embed", "index.css");
+
+describe("embedTailwindSources", () => {
+  it("maps Laravel include_dirs to paths relative to embed/index.css", () => {
+    const root = mkdtempSync(join(tmpdir(), "dslinter-embed-src-"));
+    mkdirSync(join(root, "resources", "js", "components"), { recursive: true });
+    writeFileSync(
+      join(root, ".dslinter.json"),
+      JSON.stringify({ include_dirs: ["resources/js/components"] }),
+    );
+
+    const paths = embedSourcePathsRelativeToCss(root, packageRoot, embedCssPath);
+    expect(paths.length).toBe(1);
+    expect(paths[0]).toMatch(/resources\/js\/components$/);
+    expect(resolve(join(packageRoot, "embed"), paths[0]!)).toBe(
+      join(root, "resources", "js", "components"),
+    );
+  });
+
+  it("falls back to src when include_dirs is absent", () => {
+    const root = mkdtempSync(join(tmpdir(), "dslinter-embed-fallback-"));
+    mkdirSync(join(root, "src", "components"), { recursive: true });
+
+    const absDirs = resolveEmbedConsumerSourceDirs(root, packageRoot);
+    expect(absDirs).toEqual([join(root, "src")]);
+  });
+
+  it("skips include_dirs that do not exist on disk", () => {
+    const root = mkdtempSync(join(tmpdir(), "dslinter-embed-missing-"));
+    writeFileSync(
+      join(root, ".dslinter.json"),
+      JSON.stringify({ include_dirs: ["resources/js/components"] }),
+    );
+
+    expect(resolveEmbedConsumerSourceDirs(root, packageRoot)).toEqual([]);
+  });
+
+  it("buildEmbedIndexCss splices consumer @source after dashboard src", () => {
+    const base = `@import "tailwindcss";\n@source "../src";\n@import "../src/styles/dashboard-theme.css";\n`;
+    const out = buildEmbedIndexCss(base, ["../../../demo/src/components"]);
+    expect(out).toContain('@source "../src";');
+    expect(out).toContain('@source "../../../demo/src/components";');
+    expect(out.indexOf('../src";')).toBeLessThan(
+      out.indexOf("demo/src/components"),
+    );
+  });
+
+  it("shouldInjectEmbedConsumerSources when scan root differs from package root", () => {
+    const root = mkdtempSync(join(tmpdir(), "dslinter-embed-inject-"));
+    mkdirSync(join(root, "resources", "js", "components"), { recursive: true });
+    writeFileSync(
+      join(root, ".dslinter.json"),
+      JSON.stringify({ include_dirs: ["resources/js/components"] }),
+    );
+
+    expect(shouldInjectEmbedConsumerSources(root, packageRoot)).toBe(true);
+    expect(shouldInjectEmbedConsumerSources(packageRoot, packageRoot)).toBe(
+      false,
+    );
+  });
+});