@salty-css/core 0.2.0-alpha.2 → 0.2.0-fix-astro-fixes-06-2026.0

package/.saltyrc.schema.json

@@ -38,6 +38,16 @@
           "saltygenDir": {
             "type": "string",
             "description": "Directory where the salty css files will be generated to, relative to the project root."
+          },
+          "include": {
+            "type": "array",
+            "description": "Optional glob patterns (relative to the project root) that limit which files the compiler scans. When set and non-empty, only matching files are compiled. When omitted, the whole project is scanned. Supports **, * and ?.",
+            "items": { "type": "string" }
+          },
+          "exclude": {
+            "type": "array",
+            "description": "Optional glob patterns (relative to the project root) skipped by the compiler, in addition to the always-skipped node_modules and saltygen folders. Exclusions take precedence over include. Supports **, * and ?.",
+            "items": { "type": "string" }
           }
         },
         "required": ["dir", "framework"]

package/bin/main.cjs

@@ -85,14 +85,15 @@ const getDefaultProject = async (rootDir = process.cwd()) => {
   const rc = await readRc(rootDir);
   return rc.defaultProject;
 };
-const upsertProjectInRc = (existingRaw, relativeProjectPath, framework) => {
+const upsertProjectInRc = (existingRaw, relativeProjectPath, framework, pathDefaults = {}) => {
   const projectPath = path.join(relativeProjectPath, framework.srcDirectory);
+  const newEntry = { dir: projectPath, framework: framework.name, ...pathDefaults };
   if (existingRaw === void 0) {
     const fresh = {
       $schema: SALTYRC_SCHEMA,
       info: SALTYRC_INFO,
       defaultProject: projectPath,
-      projects: [{ dir: projectPath, framework: framework.name }]
+      projects: [newEntry]
     };
     return { content: JSON.stringify(fresh, null, 2), changed: true, created: true };
   }
@@ -100,15 +101,15 @@ const upsertProjectInRc = (existingRaw, relativeProjectPath, framework) => {
   const projects = rc.projects || [];
   const exists = projects.some((p) => p.dir === projectPath);
   if (exists) return { content: existingRaw, changed: false, created: false };
-  projects.push({ dir: projectPath, framework: framework.name });
+  projects.push(newEntry);
   rc.projects = [...projects];
   const next = JSON.stringify(rc, null, 2);
   return { content: next, changed: next !== existingRaw, created: false };
 };
-const writeProjectToRc = async (cwd, relativeProjectPath, framework) => {
+const writeProjectToRc = async (cwd, relativeProjectPath, framework, pathDefaults = {}) => {
   const path2 = saltyrcPath(cwd);
   const existing = await readRawRc(cwd);
-  const { content, changed, created } = upsertProjectInRc(existing, relativeProjectPath, framework);
+  const { content, changed, created } = upsertProjectInRc(existing, relativeProjectPath, framework, pathDefaults);
   if (!changed) return false;
   if (created) compiler_saltyCompiler.logger.info("Creating file: " + path2);
   else compiler_saltyCompiler.logger.info("Edit file: " + path2);
@@ -580,6 +581,18 @@ const applyIntegrationPlans = async (planned) => {
   }
   return results;
 };
+const BUILD_OUTPUTS = {
+  vite: ["dist/**"],
+  next: [".next/**", "out/**"]
+};
+const computePathDefaults = ({ framework, integrations, hasSrcDir }) => {
+  if (framework === "astro") return {};
+  const exclude = [...new Set(integrations.flatMap((name) => BUILD_OUTPUTS[name] ?? []))];
+  const result = {};
+  if (hasSrcDir) result.include = ["src/**"];
+  if (exclude.length) result.exclude = exclude;
+  return result;
+};
 const writeProjectFile = async (projectDir, fileName, content) => {
   const filePath = path.join(projectDir, fileName);
   if (fs.existsSync(filePath)) {
@@ -600,7 +613,7 @@ const ensureGitignoreSaltygen = async (rootDir) => {
   compiler_saltyCompiler.logger.info("Edit file: " + path$1);
   await promises.writeFile(path$1, existing + "\n\n# Salty-CSS\nsaltygen\n");
 };
-const importSaltygenIntoCss = async (projectDir, explicitCssFile) => {
+const importSaltygenIntoCss = async (projectDir, saltygenDir, explicitCssFile) => {
   const target = explicitCssFile ?? await findGlobalCssFile(projectDir);
   if (!target) {
     compiler_saltyCompiler.logger.warn("Could not find a CSS file to import the generated CSS. Please add it manually.");
@@ -611,7 +624,7 @@ const importSaltygenIntoCss = async (projectDir, explicitCssFile) => {
   if (cssFileContent === void 0) return;
   if (cssFileContent.includes("saltygen")) return;
   const cssFileFolder = path.join(cssFilePath, "..");
-  const relPath = path.relative(cssFileFolder, path.join(projectDir, "saltygen/index.css"));
+  const relPath = path.relative(cssFileFolder, path.join(saltygenDir, "saltygen/index.css"));
   compiler_saltyCompiler.logger.info("Adding global import statement to CSS file: " + cssFilePath);
   await promises.writeFile(cssFilePath, `@import '${relPath}';
 ` + cssFileContent);
@@ -636,6 +649,7 @@ const registerInitCommand = (program) => {
       compiler_saltyCompiler.logger.info("Initializing a new Salty-CSS project!");
       const framework = await detectFramework(ctx);
       compiler_saltyCompiler.logger.info(`Detected framework: ${framework.name}`);
+      const sourceDir = path.join(ctx.projectDir, framework.srcDirectory);
       const plannedIntegrations = await planIntegrations(ctx);
       if (!ctx.skipInstall) {
         const packages = [
@@ -647,15 +661,20 @@ const registerInitCommand = (program) => {
         await npmInstall(...packages);
       }
       const projectFiles = await Promise.all([readTemplate("salty.config.ts"), readTemplate("saltygen/index.css")]);
-      await promises.mkdir(ctx.projectDir, { recursive: true });
-      await Promise.all(projectFiles.map(({ fileName, content }) => writeProjectFile(ctx.projectDir, fileName, content)));
-      await writeProjectToRc(ctx.cwd, ctx.relativeProjectPath, framework);
+      await promises.mkdir(sourceDir, { recursive: true });
+      await Promise.all(projectFiles.map(({ fileName, content }) => writeProjectFile(sourceDir, fileName, content)));
+      const pathDefaults = computePathDefaults({
+        framework: framework.name,
+        integrations: plannedIntegrations.map((p) => p.name),
+        hasSrcDir: fs.existsSync(path.join(ctx.projectDir, "src"))
+      });
+      await writeProjectToRc(ctx.cwd, ctx.relativeProjectPath, framework, pathDefaults);
       await ensureGitignoreSaltygen(ctx.cwd);
-      await importSaltygenIntoCss(ctx.projectDir, opts.cssFile);
+      await importSaltygenIntoCss(ctx.projectDir, sourceDir, opts.cssFile);
       await applyIntegrationPlans(plannedIntegrations);
       await wirePrepareScript();
       compiler_saltyCompiler.logger.info("Running the build to generate initial CSS...");
-      const compiler = new compiler_saltyCompiler.SaltyCompiler(ctx.projectDir);
+      const compiler = new compiler_saltyCompiler.SaltyCompiler(sourceDir);
       await compiler.generateCss();
       compiler_saltyCompiler.logger.info("🎉 Salty CSS project initialized successfully!");
       compiler_saltyCompiler.logger.info("Next steps:");

package/bin/main.js

@@ -82,14 +82,15 @@ const getDefaultProject = async (rootDir = process.cwd()) => {
   const rc = await readRc(rootDir);
   return rc.defaultProject;
 };
-const upsertProjectInRc = (existingRaw, relativeProjectPath, framework) => {
+const upsertProjectInRc = (existingRaw, relativeProjectPath, framework, pathDefaults = {}) => {
   const projectPath = join(relativeProjectPath, framework.srcDirectory);
+  const newEntry = { dir: projectPath, framework: framework.name, ...pathDefaults };
   if (existingRaw === void 0) {
     const fresh = {
       $schema: SALTYRC_SCHEMA,
       info: SALTYRC_INFO,
       defaultProject: projectPath,
-      projects: [{ dir: projectPath, framework: framework.name }]
+      projects: [newEntry]
     };
     return { content: JSON.stringify(fresh, null, 2), changed: true, created: true };
   }
@@ -97,15 +98,15 @@ const upsertProjectInRc = (existingRaw, relativeProjectPath, framework) => {
   const projects = rc.projects || [];
   const exists = projects.some((p) => p.dir === projectPath);
   if (exists) return { content: existingRaw, changed: false, created: false };
-  projects.push({ dir: projectPath, framework: framework.name });
+  projects.push(newEntry);
   rc.projects = [...projects];
   const next = JSON.stringify(rc, null, 2);
   return { content: next, changed: next !== existingRaw, created: false };
 };
-const writeProjectToRc = async (cwd, relativeProjectPath, framework) => {
+const writeProjectToRc = async (cwd, relativeProjectPath, framework, pathDefaults = {}) => {
   const path = saltyrcPath(cwd);
   const existing = await readRawRc(cwd);
-  const { content, changed, created } = upsertProjectInRc(existing, relativeProjectPath, framework);
+  const { content, changed, created } = upsertProjectInRc(existing, relativeProjectPath, framework, pathDefaults);
   if (!changed) return false;
   if (created) logger.info("Creating file: " + path);
   else logger.info("Edit file: " + path);
@@ -577,6 +578,18 @@ const applyIntegrationPlans = async (planned) => {
   }
   return results;
 };
+const BUILD_OUTPUTS = {
+  vite: ["dist/**"],
+  next: [".next/**", "out/**"]
+};
+const computePathDefaults = ({ framework, integrations, hasSrcDir }) => {
+  if (framework === "astro") return {};
+  const exclude = [...new Set(integrations.flatMap((name) => BUILD_OUTPUTS[name] ?? []))];
+  const result = {};
+  if (hasSrcDir) result.include = ["src/**"];
+  if (exclude.length) result.exclude = exclude;
+  return result;
+};
 const writeProjectFile = async (projectDir, fileName, content) => {
   const filePath = join(projectDir, fileName);
   if (existsSync(filePath)) {
@@ -597,7 +610,7 @@ const ensureGitignoreSaltygen = async (rootDir) => {
   logger.info("Edit file: " + path);
   await writeFile(path, existing + "\n\n# Salty-CSS\nsaltygen\n");
 };
-const importSaltygenIntoCss = async (projectDir, explicitCssFile) => {
+const importSaltygenIntoCss = async (projectDir, saltygenDir, explicitCssFile) => {
   const target = explicitCssFile ?? await findGlobalCssFile(projectDir);
   if (!target) {
     logger.warn("Could not find a CSS file to import the generated CSS. Please add it manually.");
@@ -608,7 +621,7 @@ const importSaltygenIntoCss = async (projectDir, explicitCssFile) => {
   if (cssFileContent === void 0) return;
   if (cssFileContent.includes("saltygen")) return;
   const cssFileFolder = join(cssFilePath, "..");
-  const relPath = relative(cssFileFolder, join(projectDir, "saltygen/index.css"));
+  const relPath = relative(cssFileFolder, join(saltygenDir, "saltygen/index.css"));
   logger.info("Adding global import statement to CSS file: " + cssFilePath);
   await writeFile(cssFilePath, `@import '${relPath}';
 ` + cssFileContent);
@@ -633,6 +646,7 @@ const registerInitCommand = (program) => {
       logger.info("Initializing a new Salty-CSS project!");
       const framework = await detectFramework(ctx);
       logger.info(`Detected framework: ${framework.name}`);
+      const sourceDir = join(ctx.projectDir, framework.srcDirectory);
       const plannedIntegrations = await planIntegrations(ctx);
       if (!ctx.skipInstall) {
         const packages = [
@@ -644,15 +658,20 @@ const registerInitCommand = (program) => {
         await npmInstall(...packages);
       }
       const projectFiles = await Promise.all([readTemplate("salty.config.ts"), readTemplate("saltygen/index.css")]);
-      await mkdir(ctx.projectDir, { recursive: true });
-      await Promise.all(projectFiles.map(({ fileName, content }) => writeProjectFile(ctx.projectDir, fileName, content)));
-      await writeProjectToRc(ctx.cwd, ctx.relativeProjectPath, framework);
+      await mkdir(sourceDir, { recursive: true });
+      await Promise.all(projectFiles.map(({ fileName, content }) => writeProjectFile(sourceDir, fileName, content)));
+      const pathDefaults = computePathDefaults({
+        framework: framework.name,
+        integrations: plannedIntegrations.map((p) => p.name),
+        hasSrcDir: existsSync(join(ctx.projectDir, "src"))
+      });
+      await writeProjectToRc(ctx.cwd, ctx.relativeProjectPath, framework, pathDefaults);
       await ensureGitignoreSaltygen(ctx.cwd);
-      await importSaltygenIntoCss(ctx.projectDir, opts.cssFile);
+      await importSaltygenIntoCss(ctx.projectDir, sourceDir, opts.cssFile);
       await applyIntegrationPlans(plannedIntegrations);
       await wirePrepareScript();
       logger.info("Running the build to generate initial CSS...");
-      const compiler = new SaltyCompiler(ctx.projectDir);
+      const compiler = new SaltyCompiler(sourceDir);
       await compiler.generateCss();
       logger.info("🎉 Salty CSS project initialized successfully!");
       logger.info("Next steps:");

package/bin/path-defaults.d.ts

@@ -0,0 +1,20 @@
+import { FrameworkName } from './frameworks';
+export interface PathDefaultsInput {
+    framework: FrameworkName;
+    /** Names of build integrations detected for the project, e.g. ['vite'] or ['next','eslint']. */
+    integrations: string[];
+    /** Whether a `src/` directory exists at the project root. */
+    hasSrcDir: boolean;
+}
+export interface PathDefaults {
+    include?: string[];
+    exclude?: string[];
+}
+/**
+ * Compute sensible default `include` / `exclude` globs for a freshly initialized project.
+ * - Astro is already scoped to `src/` by its plugin (it roots the compiler there), so it
+ *   gets no defaults.
+ * - React / Vite / Next: exclude known build outputs, and narrow the walk to `src/**` only
+ *   when a `src/` folder actually exists (projects with root-level salty files keep the full walk).
+ */
+export declare const computePathDefaults: ({ framework, integrations, hasSrcDir }: PathDefaultsInput) => PathDefaults;

package/bin/saltyrc.d.ts

@@ -1,5 +1,6 @@
 import { RCFile } from '../types/cli-types';
 import { FrameworkAdapter } from './frameworks';
+import { PathDefaults } from './path-defaults';
 export declare const SALTYRC_FILENAME = ".saltyrc.json";
 export declare const SALTYRC_SCHEMA = "./node_modules/@salty-css/core/.saltyrc.schema.json";
 export declare const SALTYRC_INFO = "This file is used to define projects and their configurations for Salty CSS cli. Do not delete, modify or add this file to .gitignore.";
@@ -18,7 +19,7 @@ export declare const getDefaultProject: (rootDir?: string) => Promise<string | u
  * - If the project entry already exists, returns the same content (no-op).
  * - Otherwise appends the new entry and returns updated content.
  */
-export declare const upsertProjectInRc: (existingRaw: string | undefined, relativeProjectPath: string, framework: FrameworkAdapter) => {
+export declare const upsertProjectInRc: (existingRaw: string | undefined, relativeProjectPath: string, framework: FrameworkAdapter, pathDefaults?: PathDefaults) => {
     content: string;
     changed: boolean;
     created: boolean;
@@ -27,5 +28,5 @@ export declare const upsertProjectInRc: (existingRaw: string | undefined, relati
  * Writes the saltyrc file, creating or updating the project entry for the given dir.
  * Returns true when a write occurred.
  */
-export declare const writeProjectToRc: (cwd: string, relativeProjectPath: string, framework: FrameworkAdapter) => Promise<boolean>;
+export declare const writeProjectToRc: (cwd: string, relativeProjectPath: string, framework: FrameworkAdapter, pathDefaults?: PathDefaults) => Promise<boolean>;
 export declare const getProjectFramework: (rc: RCFile, relativeProjectPath: string) => string | undefined;

package/compiler/salty-compiler.cjs

@@ -11,6 +11,7 @@ const fs = require("fs");
 const child_process = require("child_process");
 const compiler_helpers = require("./helpers.cjs");
 const toHash = require("../to-hash-DT2ImSPA.cjs");
+const globMatch = require("../glob-match-CT1uFlp-.cjs");
 const defineTemplates = require("../define-templates-Deq1aCbN.cjs");
 const module$1 = require("module");
 const parseStyles = require("../parse-styles-DWT4tDyS.cjs");
@@ -196,6 +197,23 @@ class SaltyCompiler {
       if (!projectConfig) return (_b = rcFile.projects) == null ? void 0 : _b.find((project) => project.dir === rcFile.defaultProject);
       return projectConfig;
     });
+    /**
+     * Read the optional `include` / `exclude` glob filters for the current project from
+     * `.saltyrc.json`. Used to scope which files the compiler discovers and watches.
+     */
+    __publicField(this, "getPathFilter", async () => {
+      const projectConfig = await this.getRCProjectConfig(this.projectRootDir);
+      return { include: projectConfig == null ? void 0 : projectConfig.include, exclude: projectConfig == null ? void 0 : projectConfig.exclude };
+    });
+    /**
+     * Whether a file should be compiled: it must be a salty file and pass the project's
+     * `include` / `exclude` filters. `relPath` is the path relative to the project root.
+     */
+    __publicField(this, "isAllowedSaltyFile", (file, filter) => {
+      if (!compiler_helpers.isSaltyFile(file)) return false;
+      const relPath = globMatch.normalizePath(path.relative(this.projectRootDir, file));
+      return globMatch.isPathAllowed(relPath, filter);
+    });
     __publicField(this, "getExternalModules", (coreConfigPath) => {
       if (this.cache.externalModules.length > 0) return this.cache.externalModules;
       const content = fs.readFileSync(coreConfigPath, "utf8");
@@ -286,16 +304,23 @@ ${currentFile}`;
         if (clean) clearDistDir();
         const files = /* @__PURE__ */ new Set();
         const configFiles = /* @__PURE__ */ new Set();
+        const pathFilter = await this.getPathFilter();
+        const { exclude } = pathFilter;
+        const projectRootDir = this.projectRootDir;
         async function collectFiles(src) {
           const foldersToSkip = ["node_modules", "saltygen"];
           const stats = fs.statSync(src);
           if (stats.isDirectory()) {
-            const files2 = fs.readdirSync(src);
             const shouldSkip = foldersToSkip.some((folder) => src.includes(folder));
             if (shouldSkip) return;
+            if (exclude == null ? void 0 : exclude.length) {
+              const relDir = globMatch.normalizePath(path.relative(projectRootDir, src));
+              if (relDir && !globMatch.isPathAllowed(relDir, { exclude })) return;
+            }
+            const files2 = fs.readdirSync(src);
             await Promise.all(files2.map((file) => collectFiles(path.join(src, file))));
           } else if (stats.isFile()) {
-            const validFile = compiler_helpers.isSaltyFile(src);
+            const validFile = compiler_helpers.isSaltyFile(src) && globMatch.isPathAllowed(globMatch.normalizePath(path.relative(projectRootDir, src)), pathFilter);
             if (validFile) {
               files.add(src);
               const contents = fs.readFileSync(src, "utf8");
@@ -704,7 +729,8 @@ ${css}
     __publicField(this, "generateFile", async (file) => {
       try {
         const destDir = await this.getDestDir();
-        const validFile = compiler_helpers.isSaltyFile(file);
+        const pathFilter = await this.getPathFilter();
+        const validFile = this.isAllowedSaltyFile(file, pathFilter);
         if (validFile) {
           const cssFiles = [];
           const config = await this.getConfig();

package/compiler/salty-compiler.d.ts

@@ -20,6 +20,16 @@ export declare class SaltyCompiler {
      * If no specific project configuration is found, it falls back to the default project.
      */
     private getRCProjectConfig;
+    /**
+     * Read the optional `include` / `exclude` glob filters for the current project from
+     * `.saltyrc.json`. Used to scope which files the compiler discovers and watches.
+     */
+    private getPathFilter;
+    /**
+     * Whether a file should be compiled: it must be a salty file and pass the project's
+     * `include` / `exclude` filters. `relPath` is the path relative to the project root.
+     */
+    private isAllowedSaltyFile;
     private getExternalModules;
     /**
      * Get the destination directory for generated files based on the project configuration.

package/compiler/salty-compiler.js

@@ -9,6 +9,7 @@ import { existsSync, mkdirSync, copyFileSync, readFileSync, statSync, readdirSyn
 import { execSync } from "child_process";
 import { isSaltyFile, resolveExportValue, saltyFileExtensions } from "./helpers.js";
 import { t as toHash, d as dashCase } from "../to-hash-DSoCPs8D.js";
+import { n as normalizePath, i as isPathAllowed } from "../glob-match-C28iYp1A.js";
 import { d as defineTemplates } from "../define-templates-CVhhgPnd.js";
 import { createRequire } from "module";
 import { p as parseAndJoinStyles, c as parseVariableTokens } from "../parse-styles-BlUpavVg.js";
@@ -176,6 +177,23 @@ class SaltyCompiler {
       if (!projectConfig) return (_b = rcFile.projects) == null ? void 0 : _b.find((project) => project.dir === rcFile.defaultProject);
       return projectConfig;
     });
+    /**
+     * Read the optional `include` / `exclude` glob filters for the current project from
+     * `.saltyrc.json`. Used to scope which files the compiler discovers and watches.
+     */
+    __publicField(this, "getPathFilter", async () => {
+      const projectConfig = await this.getRCProjectConfig(this.projectRootDir);
+      return { include: projectConfig == null ? void 0 : projectConfig.include, exclude: projectConfig == null ? void 0 : projectConfig.exclude };
+    });
+    /**
+     * Whether a file should be compiled: it must be a salty file and pass the project's
+     * `include` / `exclude` filters. `relPath` is the path relative to the project root.
+     */
+    __publicField(this, "isAllowedSaltyFile", (file, filter) => {
+      if (!isSaltyFile(file)) return false;
+      const relPath = normalizePath(relative(this.projectRootDir, file));
+      return isPathAllowed(relPath, filter);
+    });
     __publicField(this, "getExternalModules", (coreConfigPath) => {
       if (this.cache.externalModules.length > 0) return this.cache.externalModules;
       const content = readFileSync(coreConfigPath, "utf8");
@@ -266,16 +284,23 @@ ${currentFile}`;
         if (clean) clearDistDir();
         const files = /* @__PURE__ */ new Set();
         const configFiles = /* @__PURE__ */ new Set();
+        const pathFilter = await this.getPathFilter();
+        const { exclude } = pathFilter;
+        const projectRootDir = this.projectRootDir;
         async function collectFiles(src) {
           const foldersToSkip = ["node_modules", "saltygen"];
           const stats = statSync(src);
           if (stats.isDirectory()) {
-            const files2 = readdirSync(src);
             const shouldSkip = foldersToSkip.some((folder) => src.includes(folder));
             if (shouldSkip) return;
+            if (exclude == null ? void 0 : exclude.length) {
+              const relDir = normalizePath(relative(projectRootDir, src));
+              if (relDir && !isPathAllowed(relDir, { exclude })) return;
+            }
+            const files2 = readdirSync(src);
             await Promise.all(files2.map((file) => collectFiles(join(src, file))));
           } else if (stats.isFile()) {
-            const validFile = isSaltyFile(src);
+            const validFile = isSaltyFile(src) && isPathAllowed(normalizePath(relative(projectRootDir, src)), pathFilter);
             if (validFile) {
               files.add(src);
               const contents = readFileSync(src, "utf8");
@@ -684,7 +709,8 @@ ${css}
     __publicField(this, "generateFile", async (file) => {
       try {
         const destDir = await this.getDestDir();
-        const validFile = isSaltyFile(file);
+        const pathFilter = await this.getPathFilter();
+        const validFile = this.isAllowedSaltyFile(file, pathFilter);
         if (validFile) {
           const cssFiles = [];
           const config = await this.getConfig();

package/glob-match-C28iYp1A.js

@@ -0,0 +1,74 @@
+const normalizePath = (path) => path.replace(/\\/g, "/");
+const tokenCache = /* @__PURE__ */ new Map();
+const tokenize = (pattern) => {
+  const cached = tokenCache.get(pattern);
+  if (cached) return cached;
+  const normalized = normalizePath(pattern);
+  const tokens = [];
+  for (let i = 0; i < normalized.length; i++) {
+    const char = normalized[i];
+    if (char === "*") {
+      let stars = 1;
+      while (normalized[i + 1] === "*") {
+        i++;
+        stars++;
+      }
+      tokens.push(stars >= 2 ? { type: "globstar" } : { type: "star" });
+    } else if (char === "?") {
+      tokens.push({ type: "single" });
+    } else {
+      tokens.push({ type: "lit", char });
+    }
+  }
+  tokenCache.set(pattern, tokens);
+  return tokens;
+};
+const matchesGlob = (pattern, path) => {
+  const tokens = tokenize(pattern);
+  const normalized = normalizePath(path);
+  const P = tokens.length;
+  const S = normalized.length;
+  const memo = new Uint8Array((P + 1) * (S + 1));
+  const match = (ti, si) => {
+    const key = ti * (S + 1) + si;
+    const seen = memo[key];
+    if (seen) return seen === 2;
+    let result;
+    if (ti === P) {
+      result = si === S;
+    } else {
+      const token = tokens[ti];
+      switch (token.type) {
+        case "lit":
+          result = si < S && normalized[si] === token.char && match(ti + 1, si + 1);
+          break;
+        case "single":
+          result = si < S && normalized[si] !== "/" && match(ti + 1, si + 1);
+          break;
+        case "star":
+          result = match(ti + 1, si) || si < S && normalized[si] !== "/" && match(ti, si + 1);
+          break;
+        case "globstar":
+          result = match(ti + 1, si) || si < S && match(ti, si + 1);
+          break;
+      }
+    }
+    memo[key] = result ? 2 : 1;
+    return result;
+  };
+  return match(0, 0);
+};
+const matchesAnyGlob = (relPath, patterns) => {
+  return patterns.some((pattern) => matchesGlob(pattern, relPath));
+};
+const isPathAllowed = (relPath, { include, exclude } = {}) => {
+  if ((exclude == null ? void 0 : exclude.length) && matchesAnyGlob(relPath, exclude)) return false;
+  if (include == null ? void 0 : include.length) return matchesAnyGlob(relPath, include);
+  return true;
+};
+export {
+  matchesGlob as a,
+  isPathAllowed as i,
+  matchesAnyGlob as m,
+  normalizePath as n
+};

package/glob-match-CT1uFlp-.cjs

@@ -0,0 +1,73 @@
+"use strict";
+const normalizePath = (path) => path.replace(/\\/g, "/");
+const tokenCache = /* @__PURE__ */ new Map();
+const tokenize = (pattern) => {
+  const cached = tokenCache.get(pattern);
+  if (cached) return cached;
+  const normalized = normalizePath(pattern);
+  const tokens = [];
+  for (let i = 0; i < normalized.length; i++) {
+    const char = normalized[i];
+    if (char === "*") {
+      let stars = 1;
+      while (normalized[i + 1] === "*") {
+        i++;
+        stars++;
+      }
+      tokens.push(stars >= 2 ? { type: "globstar" } : { type: "star" });
+    } else if (char === "?") {
+      tokens.push({ type: "single" });
+    } else {
+      tokens.push({ type: "lit", char });
+    }
+  }
+  tokenCache.set(pattern, tokens);
+  return tokens;
+};
+const matchesGlob = (pattern, path) => {
+  const tokens = tokenize(pattern);
+  const normalized = normalizePath(path);
+  const P = tokens.length;
+  const S = normalized.length;
+  const memo = new Uint8Array((P + 1) * (S + 1));
+  const match = (ti, si) => {
+    const key = ti * (S + 1) + si;
+    const seen = memo[key];
+    if (seen) return seen === 2;
+    let result;
+    if (ti === P) {
+      result = si === S;
+    } else {
+      const token = tokens[ti];
+      switch (token.type) {
+        case "lit":
+          result = si < S && normalized[si] === token.char && match(ti + 1, si + 1);
+          break;
+        case "single":
+          result = si < S && normalized[si] !== "/" && match(ti + 1, si + 1);
+          break;
+        case "star":
+          result = match(ti + 1, si) || si < S && normalized[si] !== "/" && match(ti, si + 1);
+          break;
+        case "globstar":
+          result = match(ti + 1, si) || si < S && match(ti, si + 1);
+          break;
+      }
+    }
+    memo[key] = result ? 2 : 1;
+    return result;
+  };
+  return match(0, 0);
+};
+const matchesAnyGlob = (relPath, patterns) => {
+  return patterns.some((pattern) => matchesGlob(pattern, relPath));
+};
+const isPathAllowed = (relPath, { include, exclude } = {}) => {
+  if ((exclude == null ? void 0 : exclude.length) && matchesAnyGlob(relPath, exclude)) return false;
+  if (include == null ? void 0 : include.length) return matchesAnyGlob(relPath, include);
+  return true;
+};
+exports.isPathAllowed = isPathAllowed;
+exports.matchesAnyGlob = matchesAnyGlob;
+exports.matchesGlob = matchesGlob;
+exports.normalizePath = normalizePath;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@salty-css/core",
-  "version": "0.2.0-alpha.2",
+  "version": "0.2.0-fix-astro-fixes-06-2026.0",
   "main": "./dist/index.js",
   "module": "./dist/index.mjs",
   "typings": "./dist/index.d.ts",

package/types/cli-types.d.ts

@@ -6,5 +6,17 @@ export interface RCFile {
         components?: string;
         configDir?: string;
         saltygenDir?: string;
+        /**
+         * Optional glob patterns (relative to the project root) that limit which files the
+         * compiler scans. When set and non-empty, only matching files are compiled. When
+         * omitted, the whole project is scanned. Supports `**`, `*`, and `?`.
+         */
+        include?: string[];
+        /**
+         * Optional glob patterns (relative to the project root) that are skipped by the
+         * compiler, in addition to the always-skipped `node_modules` and `saltygen` folders.
+         * Exclusions take precedence over `include`. Supports `**`, `*`, and `?`.
+         */
+        exclude?: string[];
     }[];
 }

package/util/glob-match.d.ts

@@ -0,0 +1,35 @@
+/**
+ * Minimal, dependency-free glob matching for `.saltyrc.json` `include` / `exclude`.
+ *
+ * Supports the three glob tokens users expect from tsconfig-style patterns:
+ * - `**` matches any number of characters, including `/` (crosses directories).
+ * - `*`  matches any number of characters except `/` (single path segment).
+ * - `?`  matches a single character except `/`.
+ *
+ * Patterns and paths are matched with `/` as the separator; callers should
+ * normalize Windows separators before matching (see `normalizePath`).
+ *
+ * Matching is done with a memoized dynamic-programming walk rather than by
+ * translating to a `.*`-based RegExp. A regex translation of `**` → `.*` is
+ * vulnerable to catastrophic backtracking (ReDoS): a pattern like
+ * `**a**a**a…X` becomes `^.*a.*a.*a…X$` and can hang for seconds on a long
+ * non-matching path. The DP walk below visits each `(token, char)` pair at most
+ * once, giving a hard `O(pattern x path)` bound with no backtracking.
+ */
+/** Normalize a path to use `/` separators so globs match cross-platform. */
+export declare const normalizePath: (path: string) => string;
+/** True when `path` matches the glob `pattern` (full, anchored match). */
+export declare const matchesGlob: (pattern: string, path: string) => boolean;
+/** True when `relPath` matches at least one of the glob `patterns`. */
+export declare const matchesAnyGlob: (relPath: string, patterns: string[]) => boolean;
+export interface PathFilterOptions {
+    include?: string[];
+    exclude?: string[];
+}
+/**
+ * Decide whether a project-relative path is allowed by the configured filters.
+ * - Anything matching `exclude` is rejected.
+ * - When `include` is non-empty, only matching paths are allowed.
+ * - When `include` is empty/undefined, everything not excluded is allowed.
+ */
+export declare const isPathAllowed: (relPath: string, { include, exclude }?: PathFilterOptions) => boolean;

package/util/index.cjs

@@ -1,6 +1,7 @@
 "use strict";
 Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
 const toHash = require("../to-hash-DT2ImSPA.cjs");
+const globMatch = require("../glob-match-CT1uFlp-.cjs");
 const pascalCase = require("../pascal-case-By_l58S-.cjs");
 function camelCase(str) {
   if (!str) return "";
@@ -9,5 +10,9 @@ function camelCase(str) {
 }
 exports.dashCase = toHash.dashCase;
 exports.toHash = toHash.toHash;
+exports.isPathAllowed = globMatch.isPathAllowed;
+exports.matchesAnyGlob = globMatch.matchesAnyGlob;
+exports.matchesGlob = globMatch.matchesGlob;
+exports.normalizePath = globMatch.normalizePath;
 exports.pascalCase = pascalCase.pascalCase;
 exports.camelCase = camelCase;

package/util/index.d.ts

@@ -1,4 +1,5 @@
 export * from './camel-case';
 export * from './dash-case';
+export * from './glob-match';
 export * from './pascal-case';
 export * from './to-hash';

package/util/index.js

@@ -1,4 +1,5 @@
 import { d, t } from "../to-hash-DSoCPs8D.js";
+import { i, m, a, n } from "../glob-match-C28iYp1A.js";
 import { p } from "../pascal-case-F3Usi5Wf.js";
 function camelCase(str) {
   if (!str) return "";
@@ -8,6 +9,10 @@ function camelCase(str) {
 export {
   camelCase,
   d as dashCase,
+  i as isPathAllowed,
+  m as matchesAnyGlob,
+  a as matchesGlob,
+  n as normalizePath,
   p as pascalCase,
   t as toHash
 };