@pandacss/node 0.22.1 → 0.24.0

package/dist/index.mjs

@@ -27,9 +27,9 @@ var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__ge
   mod
 ));
 
-// ../../node_modules/.pnpm/tsup@7.1.0_typescript@5.3.3/node_modules/tsup/assets/esm_shims.js
+// ../../node_modules/.pnpm/tsup@8.0.1_typescript@5.3.3/node_modules/tsup/assets/esm_shims.js
 var init_esm_shims = __esm({
-  "../../node_modules/.pnpm/tsup@7.1.0_typescript@5.3.3/node_modules/tsup/assets/esm_shims.js"() {
+  "../../node_modules/.pnpm/tsup@8.0.1_typescript@5.3.3/node_modules/tsup/assets/esm_shims.js"() {
     "use strict";
   }
 });
@@ -688,7 +688,7 @@ function analyzeTokens(ctx, options = {}) {
   const minify = ctx.config.minify;
   ctx.config.optimize = true;
   ctx.config.minify = false;
-  const css2 = "";
+  const css = "";
   const minifiedCss = "";
   ctx.config.minify = minify;
   const start = performance.now();
@@ -702,11 +702,11 @@ function analyzeTokens(ctx, options = {}) {
         classify: classifyMs
       },
       fileSizes: {
-        lineCount: css2.split("\n").length,
-        normal: filesize(Buffer.byteLength(css2, "utf-8")),
+        lineCount: css.split("\n").length,
+        normal: filesize(Buffer.byteLength(css, "utf-8")),
         minified: filesize(Buffer.byteLength(minifiedCss, "utf-8")),
         gzip: {
-          normal: filesize(gzipSizeSync(css2)),
+          normal: filesize(gzipSizeSync(css)),
           minified: filesize(gzipSizeSync(minifiedCss))
         }
       }
@@ -746,13 +746,42 @@ var writeAnalyzeJSON = (filePath, result, ctx) => {
   );
 };
 
+// src/build-info.ts
+init_esm_shims();
+import { colors, logger as logger2 } from "@pandacss/logger";
+
+// package.json
+var version = "0.24.0";
+
+// src/build-info.ts
+async function buildInfo(ctx, outfile) {
+  const { filesWithCss, files } = ctx.parseFiles();
+  logger2.info("cli", `Found ${colors.bold(`${filesWithCss.length}/${files.length}`)} files using Panda`);
+  const minify = ctx.config.minify;
+  logger2.info("cli", `Writing ${minify ? "[min] " : " "}${colors.bold(outfile)}`);
+  const output = JSON.stringify(
+    {
+      schemaVersion: version,
+      styles: ctx.encoder.toJSON()
+    },
+    null,
+    minify ? 0 : 2
+  );
+  ctx.output.ensure(outfile, process.cwd());
+  await ctx.runtime.fs.writeFile(outfile, output);
+  logger2.info("cli", "Done!");
+}
+
 // src/builder.ts
 init_esm_shims();
+import { findConfig } from "@pandacss/config";
 import { optimizeCss } from "@pandacss/core";
 import { ConfigNotFoundError } from "@pandacss/error";
 import { logger as logger6 } from "@pandacss/logger";
-import { existsSync } from "fs";
-import fsExtra2 from "fs-extra";
+import { existsSync, statSync } from "fs";
+
+// src/codegen.ts
+init_esm_shims();
 
 // ../../node_modules/.pnpm/p-limit@4.0.0/node_modules/p-limit/index.js
 init_esm_shims();
@@ -861,372 +890,6 @@ function pLimit(concurrency) {
   return generator;
 }
 
-// src/builder.ts
-import { resolve as resolve2 } from "pathe";
-
-// src/config.ts
-init_esm_shims();
-import { convertTsPathsToRegexes, loadConfigFile as loadConfigFile2 } from "@pandacss/config";
-import { createDebugger, createHooks } from "hookable";
-import { lookItUpSync } from "look-it-up";
-import { parse } from "tsconfck";
-
-// src/create-context.ts
-init_esm_shims();
-import { Generator as Generator2 } from "@pandacss/generator";
-import { logger as logger4 } from "@pandacss/logger";
-import { createParserResult, createProject } from "@pandacss/parser";
-
-// src/diff-engine.ts
-init_esm_shims();
-import { loadConfigFile } from "@pandacss/config";
-import "@pandacss/generator";
-import { dashCase } from "@pandacss/shared";
-import diff from "microdiff";
-
-// src/matcher.ts
-init_esm_shims();
-function createMatcher(id, patterns) {
-  if (!patterns?.length)
-    return () => void 0;
-  const includePatterns = [];
-  const excludePatterns = [];
-  const deduped = new Set(patterns);
-  deduped.forEach((pattern) => {
-    const regexString = pattern.replace(/\*/g, ".*");
-    if (pattern.startsWith("!")) {
-      excludePatterns.push(regexString.slice(1));
-    } else {
-      includePatterns.push(regexString);
-    }
-  });
-  const include = new RegExp(includePatterns.join("|"));
-  const exclude = new RegExp(excludePatterns.join("|"));
-  return (path2) => {
-    if (excludePatterns.length && exclude.test(path2))
-      return;
-    return include.test(path2) ? id : void 0;
-  };
-}
-
-// src/diff-engine.ts
-var all = ["outdir", "forceConsistentTypeExtension", "outExtension"];
-var format = ["syntax", "hash", "prefix", "separator"];
-var tokens = ["utilities", "conditions", "theme.tokens", "theme.semanticTokens", "theme.breakpoints"];
-var jsx = ["jsxFramework", "jsxFactory", "jsxStyleProps", "syntax"];
-var css = ["layers", "optimize", "minify"];
-var common = tokens.concat(jsx, format);
-var artifactConfigDeps = {
-  helpers: ["syntax", "jsxFramework"],
-  keyframes: ["theme.keyframes", "layers"],
-  "design-tokens": ["layers", "!utilities.*.className"].concat(tokens),
-  types: ["!utilities.*.className"].concat(common),
-  "css-fn": common,
-  cva: ["syntax"],
-  sva: ["syntax"],
-  cx: [],
-  "create-recipe": ["separator", "prefix", "hash"],
-  "recipes-index": ["theme.recipes", "theme.slotRecipes"],
-  recipes: ["theme.recipes", "theme.slotRecipes"],
-  "patterns-index": ["syntax", "patterns"],
-  patterns: ["syntax", "patterns"],
-  "jsx-is-valid-prop": common,
-  "jsx-factory": jsx,
-  "jsx-helpers": jsx,
-  "jsx-patterns": jsx.concat("patterns"),
-  "jsx-patterns-index": jsx.concat("patterns"),
-  "css-index": ["syntax"],
-  "reset.css": ["preflight", "layers"],
-  "global.css": ["globalCss"].concat(css),
-  "static.css": ["staticCss", "theme.breakpoints"].concat(css),
-  "styles.css": tokens.concat(format),
-  "package.json": ["emitPackage"]
-};
-var configDeps = {
-  artifacts: artifactConfigDeps
-};
-var matchers = {
-  artifacts: Object.keys(configDeps.artifacts).map((key) => {
-    const paths = configDeps.artifacts[key];
-    if (!paths.length)
-      return () => void 0;
-    return createMatcher(key, paths.concat(all));
-  })
-};
-var DiffEngine = class {
-  constructor(ctx) {
-    this.ctx = ctx;
-    this.previousConfig = ctx.conf.deserialize();
-  }
-  previousConfig;
-  /**
-   * Reload config from disk and refresh the context
-   */
-  async reloadConfigAndRefreshContext(fn) {
-    const conf = await loadConfigFile({ cwd: this.ctx.config.cwd, file: this.ctx.conf.path });
-    return this.refresh(conf, fn);
-  }
-  /**
-   * Update the context from the refreshed config
-   * then persist the changes on each affected engines
-   * Returns the list of affected artifacts/engines
-   */
-  refresh(conf, fn) {
-    const affected = {
-      artifacts: /* @__PURE__ */ new Set(),
-      hasConfigChanged: false,
-      diffs: []
-    };
-    if (!this.previousConfig) {
-      affected.hasConfigChanged = true;
-      return affected;
-    }
-    const newConfig = conf.deserialize();
-    const configDiff = diff(this.previousConfig, newConfig);
-    if (!configDiff.length) {
-      return affected;
-    }
-    affected.hasConfigChanged = true;
-    affected.diffs = configDiff;
-    this.previousConfig = newConfig;
-    fn?.(conf);
-    configDiff.forEach((change) => {
-      const changePath = change.path.join(".");
-      matchers.artifacts.forEach((matcher) => {
-        const id = matcher(changePath);
-        if (!id)
-          return;
-        if (id === "recipes") {
-          const name = dashCase(change.path.slice(1, 3).join("."));
-          affected.artifacts.add(name);
-        }
-        if (id === "patterns") {
-          const name = dashCase(change.path.slice(0, 2).join("."));
-          affected.artifacts.add(name);
-        }
-        affected.artifacts.add(id);
-      });
-    });
-    return affected;
-  }
-};
-
-// src/node-runtime.ts
-init_esm_shims();
-import { logger as logger2 } from "@pandacss/logger";
-import chokidar from "chokidar";
-import glob from "fast-glob";
-import fsExtra from "fs-extra";
-import { dirname, extname, isAbsolute, join, relative, sep } from "pathe";
-var nodeRuntime = {
-  cwd() {
-    return process.cwd();
-  },
-  env(name) {
-    return process.env[name];
-  },
-  path: {
-    join,
-    relative,
-    dirname,
-    extname,
-    isAbsolute,
-    sep,
-    abs(cwd, str) {
-      return isAbsolute(str) ? str : join(cwd, str);
-    }
-  },
-  fs: {
-    existsSync: fsExtra.existsSync,
-    readFileSync(filePath) {
-      return fsExtra.readFileSync(filePath, "utf8");
-    },
-    glob(opts) {
-      if (!opts.include)
-        return [];
-      const ignore = opts.exclude ?? [];
-      if (!ignore.length) {
-        ignore.push("**/*.d.ts");
-      }
-      return glob.sync(opts.include, { cwd: opts.cwd, ignore, absolute: true });
-    },
-    writeFile: fsExtra.writeFile,
-    writeFileSync: fsExtra.writeFileSync,
-    readDirSync: fsExtra.readdirSync,
-    rmDirSync: fsExtra.emptyDirSync,
-    rmFileSync: fsExtra.removeSync,
-    ensureDirSync(path2) {
-      return fsExtra.ensureDirSync(path2);
-    },
-    watch(options) {
-      const { include, exclude, cwd, poll } = options;
-      const coalesce = poll || process.platform === "win32";
-      const watcher = chokidar.watch(include, {
-        usePolling: poll,
-        cwd,
-        ignoreInitial: true,
-        ignorePermissionErrors: true,
-        ignored: exclude,
-        awaitWriteFinish: coalesce ? { stabilityThreshold: 50, pollInterval: 10 } : false
-      });
-      logger2.debug("watch:file", `watching [${include}]`);
-      process.once("SIGINT", async () => {
-        await watcher.close();
-      });
-      return watcher;
-    }
-  }
-};
-process.setMaxListeners(Infinity);
-process.on("unhandledRejection", (reason) => {
-  logger2.error("\u274C", reason);
-});
-process.on("uncaughtException", (reason) => {
-  logger2.error("\u274C", reason);
-});
-
-// src/output-engine.ts
-init_esm_shims();
-import { logger as logger3 } from "@pandacss/logger";
-var PandaOutputEngine = class {
-  paths;
-  fs;
-  path;
-  constructor({ paths, runtime: { path: path2, fs } }) {
-    this.paths = paths;
-    this.fs = fs;
-    this.path = path2;
-  }
-  empty() {
-    this.fs.rmDirSync(this.path.join(...this.paths.root));
-  }
-  async write(output) {
-    if (!output)
-      return;
-    const { dir = this.paths.root, files } = output;
-    this.fs.ensureDirSync(this.path.join(...dir));
-    return Promise.allSettled(
-      files.map(async (artifact) => {
-        if (!artifact?.code)
-          return;
-        const { file, code } = artifact;
-        const absPath = this.path.join(...dir, file);
-        logger3.debug("write:file", dir.slice(-1).concat(file).join("/"));
-        return this.fs.writeFile(absPath, code);
-      })
-    );
-  }
-};
-
-// src/create-context.ts
-var PandaContext = class extends Generator2 {
-  runtime;
-  project;
-  getFiles;
-  output;
-  diff;
-  constructor(conf) {
-    super(conf);
-    const config = conf.config;
-    this.runtime = nodeRuntime;
-    config.cwd ||= this.runtime.cwd();
-    if (config.logLevel) {
-      logger4.level = config.logLevel;
-    }
-    const { include, exclude, cwd } = config;
-    this.getFiles = () => this.runtime.fs.glob({ include, exclude, cwd });
-    this.project = createProject({
-      ...conf.tsconfig,
-      getFiles: this.getFiles.bind(this),
-      readFile: this.runtime.fs.readFileSync.bind(this),
-      hooks: conf.hooks,
-      parserOptions: { join: this.runtime.path.join, ...this.parserOptions }
-    });
-    this.output = new PandaOutputEngine(this);
-    this.diff = new DiffEngine(this);
-  }
-  appendFilesCss() {
-    const files = this.getFiles();
-    const filesWithCss = [];
-    const mergedResult = createParserResult();
-    files.forEach((file) => {
-      const measure = logger4.time.debug(`Parsed ${file}`);
-      const result = this.project.parseSourceFile(file);
-      measure();
-      if (!result)
-        return;
-      mergedResult.merge(result);
-      filesWithCss.push(file);
-    });
-    this.appendParserCss(mergedResult);
-    return filesWithCss;
-  }
-  appendAllCss() {
-    this.appendLayerParams();
-    this.appendBaselineCss();
-    this.appendFilesCss();
-  }
-  async writeCss() {
-    return this.output.write({
-      id: "styles.css",
-      dir: this.paths.root,
-      files: [{ file: "styles.css", code: this.getCss() }]
-    });
-  }
-};
-
-// src/config.ts
-var configs = [".ts", ".js", ".mts", ".mjs", ".cts", ".cjs"];
-function findConfig() {
-  for (const config of configs) {
-    const result = lookItUpSync(`panda.config${config}`);
-    if (result) {
-      return result;
-    }
-  }
-}
-async function loadConfigAndCreateContext(options = {}) {
-  const { config, configPath } = options;
-  const cwd = options.cwd ?? options?.config?.cwd ?? process.cwd();
-  const conf = await loadConfigFile2({ cwd, file: configPath });
-  if (config) {
-    Object.assign(conf.config, config);
-  }
-  if (options.cwd) {
-    conf.config.cwd = options.cwd;
-  }
-  const tsconfigResult = await parse(conf.path, {
-    root: cwd,
-    // @ts-ignore
-    resolveWithEmptyIfConfigNotFound: true
-  });
-  if (tsconfigResult) {
-    conf.tsconfig = tsconfigResult.tsconfig;
-    conf.tsconfigFile = tsconfigResult.tsconfigFile;
-    const options2 = tsconfigResult.tsconfig?.compilerOptions;
-    if (options2?.paths) {
-      const baseUrl = options2.baseUrl;
-      conf.tsOptions = {
-        baseUrl,
-        pathMappings: convertTsPathsToRegexes(options2.paths, baseUrl ?? cwd)
-      };
-    }
-  }
-  conf.config.outdir ??= "styled-system";
-  const hooks = createHooks();
-  if (conf.config.hooks) {
-    hooks.addHooks(conf.config.hooks);
-  }
-  await hooks.callHook("config:resolved", conf);
-  if (conf.config.logLevel === "debug") {
-    createDebugger(hooks, { tag: "panda" });
-  }
-  return new PandaContext({ ...conf, hooks });
-}
-
-// src/emit-artifact.ts
-init_esm_shims();
-
 // src/cli-box.ts
 init_esm_shims();
 
@@ -1584,10 +1247,10 @@ function _supportsColor(haveStream, { streamIsTTY, sniffFlags = true } = {}) {
     return 3;
   }
   if ("TERM_PROGRAM" in env) {
-    const version = Number.parseInt((env.TERM_PROGRAM_VERSION || "").split(".")[0], 10);
+    const version2 = Number.parseInt((env.TERM_PROGRAM_VERSION || "").split(".")[0], 10);
     switch (env.TERM_PROGRAM) {
       case "iTerm.app": {
-        return version >= 3 ? 3 : 2;
+        return version2 >= 3 ? 3 : 2;
       }
       case "Apple_Terminal": {
         return 2;
@@ -2539,11 +2202,11 @@ var createBox = (options) => boxen(options.content, {
   titleAlignment: "center"
 });
 
-// src/emit-artifact.ts
+// src/codegen.ts
 var randomWords = ["Sweet", "Divine", "Pandalicious", "Super"];
 var pickRandom = (arr) => arr[Math.floor(Math.random() * arr.length)];
 var limit = pLimit(20);
-async function emitArtifacts(ctx, ids) {
+async function codegen(ctx, ids) {
   if (ctx.config.clean)
     ctx.output.empty();
   const promises = ctx.getArtifacts(ids).map((artifact) => limit(() => ctx.output.write(artifact)));
@@ -2558,28 +2221,318 @@ async function emitArtifacts(ctx, ids) {
   };
 }
 
-// src/extract.ts
+// src/config.ts
 init_esm_shims();
-import { logger as logger5 } from "@pandacss/logger";
-function extractFile(ctx, filePath) {
-  const file = ctx.runtime.path.abs(ctx.config.cwd, filePath);
-  logger5.debug("file:extract", file);
-  const measure = logger5.time.debug(`Extracted ${file}`);
-  let result;
-  try {
-    result = ctx.project.parseSourceFile(file);
-  } catch (error) {
-    logger5.error("file:parse", error);
-  }
-  ctx.appendParserCss(result);
-  measure();
-  return result;
-}
+import { convertTsPathsToRegexes, loadConfig as loadConfig2 } from "@pandacss/config";
+import { createDebugger, createHooks } from "hookable";
+import { parse } from "tsconfck";
 
-// src/parse-dependency.ts
+// src/create-context.ts
+init_esm_shims();
+import { Generator as Generator2 } from "@pandacss/generator";
+import { logger as logger5 } from "@pandacss/logger";
+import { Project } from "@pandacss/parser";
+import { debounce } from "perfect-debounce";
+
+// src/diff-engine.ts
+init_esm_shims();
+import { diffConfigs, loadConfig } from "@pandacss/config";
+import "@pandacss/generator";
+var DiffEngine = class {
+  constructor(ctx) {
+    this.ctx = ctx;
+    this.prevConfig = ctx.conf.deserialize();
+  }
+  prevConfig;
+  /**
+   * Reload config from disk and refresh the context
+   */
+  async reloadConfigAndRefreshContext(fn) {
+    const conf = await loadConfig({ cwd: this.ctx.config.cwd, file: this.ctx.conf.path });
+    return this.refresh(conf, fn);
+  }
+  /**
+   * Update the context from the refreshed config
+   * then persist the changes on each affected engines
+   * Returns the list of affected artifacts/engines
+   */
+  refresh(conf, fn) {
+    const affected = diffConfigs(() => conf.deserialize(), this.prevConfig);
+    if (!affected.hasConfigChanged || !this.prevConfig)
+      return affected;
+    fn?.(conf);
+    this.prevConfig = conf.deserialize();
+    return affected;
+  }
+};
+
+// src/node-runtime.ts
+init_esm_shims();
+import { logger as logger3 } from "@pandacss/logger";
+import chokidar from "chokidar";
+import glob from "fast-glob";
+import fsExtra from "fs-extra";
+import { dirname, extname, isAbsolute, join, relative, sep, resolve } from "pathe";
+var nodeRuntime = {
+  cwd() {
+    return process.cwd();
+  },
+  env(name) {
+    return process.env[name];
+  },
+  path: {
+    join,
+    relative,
+    dirname,
+    extname,
+    isAbsolute,
+    sep,
+    resolve,
+    abs(cwd, str) {
+      return isAbsolute(str) ? str : join(cwd, str);
+    }
+  },
+  fs: {
+    existsSync: fsExtra.existsSync,
+    readFileSync(filePath) {
+      return fsExtra.readFileSync(filePath, "utf8");
+    },
+    glob(opts) {
+      if (!opts.include)
+        return [];
+      const ignore = opts.exclude ?? [];
+      if (!ignore.length) {
+        ignore.push("**/*.d.ts");
+      }
+      return glob.sync(opts.include, { cwd: opts.cwd, ignore, absolute: true });
+    },
+    writeFile: fsExtra.writeFile,
+    writeFileSync: fsExtra.writeFileSync,
+    readDirSync: fsExtra.readdirSync,
+    rmDirSync: fsExtra.emptyDirSync,
+    rmFileSync: fsExtra.removeSync,
+    ensureDirSync(path) {
+      return fsExtra.ensureDirSync(path);
+    },
+    watch(options) {
+      const { include, exclude, cwd, poll } = options;
+      const coalesce = poll || process.platform === "win32";
+      const watcher = chokidar.watch(include, {
+        usePolling: poll,
+        cwd,
+        ignoreInitial: true,
+        ignorePermissionErrors: true,
+        ignored: exclude,
+        awaitWriteFinish: coalesce ? { stabilityThreshold: 50, pollInterval: 10 } : false
+      });
+      logger3.debug("watch:file", `watching [${include}]`);
+      process.once("SIGINT", async () => {
+        await watcher.close();
+      });
+      return watcher;
+    }
+  }
+};
+process.setMaxListeners(Infinity);
+process.on("unhandledRejection", (reason) => {
+  logger3.error("\u274C", reason);
+});
+process.on("uncaughtException", (reason) => {
+  logger3.error("\u274C", reason);
+});
+
+// src/output-engine.ts
+init_esm_shims();
+import { logger as logger4 } from "@pandacss/logger";
+var OutputEngine = class {
+  paths;
+  fs;
+  path;
+  constructor(options) {
+    const { paths, runtime } = options;
+    this.paths = paths;
+    this.fs = runtime.fs;
+    this.path = runtime.path;
+  }
+  empty = () => {
+    this.fs.rmDirSync(this.path.join(...this.paths.root));
+  };
+  ensure = (file, cwd) => {
+    const outPath = this.path.resolve(cwd, file);
+    const dirname2 = this.path.dirname(outPath);
+    this.fs.ensureDirSync(dirname2);
+    return outPath;
+  };
+  write = (output) => {
+    if (!output)
+      return;
+    const { dir = this.paths.root, files } = output;
+    this.fs.ensureDirSync(this.path.join(...dir));
+    return Promise.allSettled(
+      files.map(async (artifact) => {
+        if (!artifact?.code)
+          return;
+        const { file, code } = artifact;
+        const absPath = this.path.join(...dir, file);
+        logger4.debug("write:file", dir.slice(-1).concat(file).join("/"));
+        return this.fs.writeFile(absPath, code);
+      })
+    );
+  };
+};
+
+// src/create-context.ts
+var PandaContext = class extends Generator2 {
+  runtime;
+  project;
+  output;
+  diff;
+  constructor(conf) {
+    super(conf);
+    const config = conf.config;
+    this.runtime = nodeRuntime;
+    config.cwd ||= this.runtime.cwd();
+    if (config.logLevel) {
+      logger5.level = config.logLevel;
+    }
+    this.project = new Project({
+      ...conf.tsconfig,
+      getFiles: this.getFiles.bind(this),
+      readFile: this.runtime.fs.readFileSync.bind(this),
+      hooks: conf.hooks,
+      parserOptions: {
+        ...this.parserOptions,
+        join: this.runtime.path.join || this.parserOptions.join
+      }
+    });
+    this.output = new OutputEngine(this);
+    this.diff = new DiffEngine(this);
+  }
+  getFiles = () => {
+    const { include, exclude, cwd } = this.config;
+    return this.runtime.fs.glob({ include, exclude, cwd });
+  };
+  parseFile = (filePath, styleEncoder) => {
+    const file = this.runtime.path.abs(this.config.cwd, filePath);
+    logger5.debug("file:extract", file);
+    const measure = logger5.time.debug(`Parsed ${file}`);
+    let result;
+    try {
+      const encoder = styleEncoder || this.parserOptions.encoder;
+      result = this.project.parseSourceFile(file, encoder);
+    } catch (error) {
+      logger5.error("file:extract", error);
+    }
+    measure();
+    return result;
+  };
+  parseFiles = (styleEncoder) => {
+    const encoder = styleEncoder || this.parserOptions.encoder;
+    const files = this.getFiles();
+    const filesWithCss = [];
+    const results = [];
+    files.forEach((file) => {
+      const measure = logger5.time.debug(`Parsed ${file}`);
+      const result = this.project.parseSourceFile(file, encoder);
+      measure();
+      if (!result || result.isEmpty() || encoder.isEmpty())
+        return;
+      filesWithCss.push(file);
+      results.push(result);
+    });
+    return {
+      filesWithCss,
+      files,
+      results
+    };
+  };
+  writeCss = (sheet) => {
+    return this.output.write({
+      id: "styles.css",
+      dir: this.paths.root,
+      files: [{ file: "styles.css", code: this.getCss(sheet) }]
+    });
+  };
+  watchConfig = (cb, opts) => {
+    const { cwd, poll, exclude } = opts ?? {};
+    logger5.info("ctx:watch", this.messages.configWatch());
+    const watcher = this.runtime.fs.watch({
+      include: this.conf.dependencies,
+      exclude,
+      cwd,
+      poll
+    });
+    watcher.on(
+      "change",
+      debounce(async () => {
+        logger5.info("ctx:change", "config changed, rebuilding...");
+        await cb();
+      })
+    );
+  };
+  watchFiles = (cb) => {
+    const { include, exclude, poll, cwd } = this.config;
+    logger5.info("ctx:watch", this.messages.watch());
+    const watcher = this.runtime.fs.watch({
+      include,
+      exclude,
+      poll,
+      cwd
+    });
+    watcher.on(
+      "all",
+      debounce(async (event, file) => {
+        logger5.info(`file:${event}`, file);
+        await cb(event, file);
+      })
+    );
+  };
+};
+
+// src/config.ts
+async function loadConfigAndCreateContext(options = {}) {
+  const { config, configPath } = options;
+  const cwd = options.cwd ?? options?.config?.cwd ?? process.cwd();
+  const conf = await loadConfig2({ cwd, file: configPath });
+  if (config) {
+    Object.assign(conf.config, config);
+  }
+  if (options.cwd) {
+    conf.config.cwd = options.cwd;
+  }
+  const tsconfigResult = await parse(conf.path, {
+    root: cwd,
+    // @ts-ignore
+    resolveWithEmptyIfConfigNotFound: true
+  });
+  if (tsconfigResult) {
+    conf.tsconfig = tsconfigResult.tsconfig;
+    conf.tsconfigFile = tsconfigResult.tsconfigFile;
+    const options2 = tsconfigResult.tsconfig?.compilerOptions;
+    if (options2?.paths) {
+      const baseUrl = options2.baseUrl;
+      conf.tsOptions = {
+        baseUrl,
+        pathMappings: convertTsPathsToRegexes(options2.paths, baseUrl ?? cwd)
+      };
+    }
+  }
+  conf.config.outdir ??= "styled-system";
+  const hooks = createHooks();
+  if (conf.config.hooks) {
+    hooks.addHooks(conf.config.hooks);
+  }
+  await hooks.callHook("config:resolved", conf);
+  if (conf.config.logLevel === "debug") {
+    createDebugger(hooks, { tag: "panda" });
+  }
+  return new PandaContext({ ...conf, hooks });
+}
+
+// src/parse-dependency.ts
 init_esm_shims();
 import isGlob from "is-glob";
-import { resolve } from "pathe";
+import { resolve as resolve2 } from "pathe";
 
 // src/parse-glob.ts
 init_esm_shims();
@@ -2610,9 +2563,9 @@ function parseDependency(fileOrGlob) {
   let message = null;
   if (isGlob(fileOrGlob)) {
     const { base, glob: glob2 } = parseGlob(fileOrGlob);
-    message = { type: "dir-dependency", dir: resolve(base), glob: glob2 };
+    message = { type: "dir-dependency", dir: resolve2(base), glob: glob2 };
   } else {
-    message = { type: "dependency", file: resolve(fileOrGlob) };
+    message = { type: "dependency", file: resolve2(fileOrGlob) };
   }
   if (message.type === "dir-dependency" && process.env.ROLLUP_WATCH === "true") {
     message = { type: "dependency", file: message.dir };
@@ -2621,18 +2574,17 @@ function parseDependency(fileOrGlob) {
 }
 
 // src/builder.ts
-var parserResultMap = /* @__PURE__ */ new Map();
 var fileModifiedMap = /* @__PURE__ */ new Map();
-var limit2 = pLimit(20);
 var Builder = class {
   /**
    * The current panda context
    */
   context;
   hasEmitted = false;
+  filesMeta;
   affecteds;
-  getConfigPath = () => {
-    const configPath = findConfig();
+  getConfigPath = (cwd) => {
+    const configPath = findConfig({ cwd });
     if (!configPath) {
       throw new ConfigNotFoundError();
     }
@@ -2640,35 +2592,36 @@ var Builder = class {
   };
   setup = async (options = {}) => {
     logger6.debug("builder", "\u{1F6A7} Setup");
-    const configPath = options.configPath ?? this.getConfigPath();
+    const configPath = options.configPath ?? this.getConfigPath(options.cwd);
     if (!this.context) {
       return this.setupContext({ configPath, cwd: options.cwd });
     }
     const ctx = this.getContextOrThrow();
     this.affecteds = await ctx.diff.reloadConfigAndRefreshContext((conf) => {
       this.context = new PandaContext({ ...conf, hooks: ctx.hooks });
-      this.context.appendBaselineCss();
     });
+    logger6.debug("builder", this.affecteds);
     if (this.affecteds.hasConfigChanged) {
       logger6.debug("builder", "\u2699\uFE0F Config changed, reloading");
       await ctx.hooks.callHook("config:change", ctx.config);
       return;
     }
-    const hasFilesChanged = this.checkFilesChanged(ctx.getFiles());
-    if (hasFilesChanged) {
+    this.filesMeta = this.checkFilesChanged(ctx.getFiles());
+    if (this.filesMeta.hasFilesChanged) {
+      logger6.debug("builder", "Files changed, invalidating them");
       ctx.project.reloadSourceFiles();
     }
   };
   async emit() {
     if (this.hasEmitted && this.affecteds?.hasConfigChanged) {
-      await emitArtifacts(this.getContextOrThrow(), Array.from(this.affecteds.artifacts));
+      logger6.debug("builder", "Emit artifacts after config change");
+      await codegen(this.getContextOrThrow(), Array.from(this.affecteds.artifacts));
     }
     this.hasEmitted = true;
   }
   setupContext = async (options) => {
     const { configPath, cwd } = options;
     const ctx = await loadConfigAndCreateContext({ configPath, cwd });
-    ctx.appendBaselineCss();
     this.context = ctx;
     return ctx;
   };
@@ -2679,62 +2632,68 @@ var Builder = class {
     return this.context;
   };
   getFileMeta = (file) => {
-    const mtime = existsSync(file) ? fsExtra2.statSync(file).mtimeMs : -Infinity;
+    const mtime = existsSync(file) ? statSync(file).mtimeMs : -Infinity;
     const isUnchanged = fileModifiedMap.has(file) && mtime === fileModifiedMap.get(file);
     return { mtime, isUnchanged };
   };
-  extractFile = async (ctx, file) => {
-    const meta = this.getFileMeta(file);
-    if (meta.isUnchanged) {
-      ctx.appendParserCss(parserResultMap.get(file));
-      return;
+  checkFilesChanged(files) {
+    const changes = /* @__PURE__ */ new Map();
+    let hasFilesChanged = false;
+    for (const file of files) {
+      const meta = this.getFileMeta(file);
+      changes.set(file, meta);
+      if (!meta.isUnchanged) {
+        hasFilesChanged = true;
+      }
     }
-    const result = extractFile(ctx, file);
+    return { changes, hasFilesChanged };
+  }
+  extractFile = (ctx, file) => {
+    const meta = this.filesMeta?.changes.get(file) ?? this.getFileMeta(file);
+    const hasConfigChanged = this.affecteds ? this.affecteds.hasConfigChanged : true;
+    if (meta.isUnchanged && !hasConfigChanged)
+      return;
+    const parserResult = ctx.parseFile(file);
     fileModifiedMap.set(file, meta.mtime);
-    if (result) {
-      parserResultMap.set(file, result);
-    }
-    return result;
+    return parserResult;
   };
-  checkFilesChanged(files) {
-    return files.some((file) => !this.getFileMeta(file).isUnchanged);
-  }
-  extract = async () => {
+  extract = () => {
+    const hasConfigChanged = this.affecteds ? this.affecteds.hasConfigChanged : true;
+    if (!this.filesMeta && !hasConfigChanged) {
+      logger6.debug("builder", "No files or config changed, skipping extract");
+      return;
+    }
     const ctx = this.getContextOrThrow();
     const files = ctx.getFiles();
-    const hasConfigChanged = this.affecteds ? this.affecteds.hasConfigChanged : false;
-    if (hasConfigChanged)
-      return;
     const done = logger6.time.info("Extracted in");
-    const promises = files.map((file) => limit2(() => this.extractFile(ctx, file)));
-    await Promise.allSettled(promises);
+    files.map((file) => this.extractFile(ctx, file));
     done();
   };
-  toString = () => {
-    const ctx = this.getContextOrThrow();
-    return ctx.getCss();
-  };
   isValidRoot = (root) => {
     const ctx = this.getContextOrThrow();
     let valid = false;
     root.walkAtRules("layer", (rule) => {
-      if (ctx.layers.isValidParams(rule.params)) {
+      if (ctx.isValidLayerParams(rule.params)) {
         valid = true;
       }
     });
     return valid;
   };
-  initialRoot;
   write = (root) => {
-    if (!this.initialRoot) {
-      this.initialRoot = root.toString();
-    }
+    const rootCssContent = root.toString();
     root.removeAll();
-    const newCss = optimizeCss(`
-    ${this.initialRoot}
-    ${this.toString()}
-    `);
-    root.append(newCss);
+    const ctx = this.getContextOrThrow();
+    const sheet = ctx.createSheet();
+    ctx.appendLayerParams(sheet);
+    ctx.appendBaselineCss(sheet);
+    ctx.appendParserCss(sheet);
+    const css = ctx.getCss(sheet);
+    root.append(
+      optimizeCss(`
+    ${rootCssContent}
+    ${css}
+    `)
+    );
   };
   registerDependency = (fn) => {
     const ctx = this.getContextOrThrow();
@@ -2745,23 +2704,64 @@ var Builder = class {
       }
     }
     for (const file of ctx.conf.dependencies) {
-      fn({ type: "dependency", file: resolve2(file) });
+      fn({ type: "dependency", file: ctx.runtime.path.resolve(file) });
     }
   };
 };
 
-// src/debug-files.ts
+// src/cssgen.ts
+init_esm_shims();
+import { logger as logger7 } from "@pandacss/logger";
+var cssgen = async (ctx, options) => {
+  const { cwd, outfile, type, minimal } = options;
+  let outPath = ctx.runtime.path.join(...ctx.paths.getFilePath("styles.css"));
+  const sheet = ctx.createSheet();
+  if (type) {
+    ctx.appendCssOfType(type, sheet);
+    if (outfile) {
+      outPath = ctx.output.ensure(outfile, cwd);
+      const css = ctx.getCss(sheet);
+      ctx.runtime.fs.writeFileSync(outfile, css);
+    } else {
+      await ctx.writeCss(sheet);
+    }
+    const msg = ctx.messages.cssArtifactComplete(type);
+    logger7.info("css:emit:path", outPath);
+    logger7.info("css:emit:artifact", msg);
+  } else {
+    if (!minimal) {
+      ctx.appendLayerParams(sheet);
+      ctx.appendBaselineCss(sheet);
+    }
+    const { files } = ctx.parseFiles();
+    ctx.appendParserCss(sheet);
+    if (outfile) {
+      outPath = ctx.output.ensure(outfile, cwd);
+      const css = ctx.getCss(sheet);
+      ctx.runtime.fs.writeFileSync(outfile, css);
+    } else {
+      await ctx.writeCss(sheet);
+    }
+    const msg = ctx.messages.buildComplete(files.length);
+    logger7.info("css:emit:path", outPath);
+    logger7.info("css:emit:out", msg);
+  }
+};
+
+// src/debug.ts
 init_esm_shims();
-import { colors, logger as logger7 } from "@pandacss/logger";
+import { colors as colors2, logger as logger8 } from "@pandacss/logger";
 import { parse as parse2 } from "pathe";
-async function debugFiles(ctx, options) {
+async function debug(ctx, options) {
   const files = ctx.getFiles();
-  const measureTotal = logger7.time.debug(`Done parsing ${files.length} files`);
-  const { fs, path: path2 } = ctx.runtime;
+  const measureTotal = logger8.time.debug(`Done parsing ${files.length} files`);
+  ctx.config.minify = false;
+  ctx.config.optimize = true;
+  const { fs, path } = ctx.runtime;
   const outdir = options.outdir;
   if (!options.dry && outdir) {
     fs.ensureDirSync(outdir);
-    logger7.info("cli", `Writing ${colors.bold(`${outdir}/config.json`)}`);
+    logger8.info("cli", `Writing ${colors2.bold(`${outdir}/config.json`)}`);
     await fs.writeFile(`${outdir}/config.json`, JSON.stringify(ctx.config, null, 2));
   }
   if (options.onlyConfig) {
@@ -2769,77 +2769,61 @@ async function debugFiles(ctx, options) {
     return;
   }
   const filesWithCss = [];
-  const results = await Promise.all(
-    files.map(async (file) => {
-      const measure = logger7.time.debug(`Parsed ${file}`);
-      const result = ctx.project.parseSourceFile(file);
-      measure();
-      return { file, result };
-    })
-  );
-  results.forEach(({ file, result }) => {
-    if (!result)
+  files.map((file) => {
+    const measure = logger8.time.debug(`Parsed ${file}`);
+    const encoder = ctx.encoder.clone();
+    const result = ctx.project.parseSourceFile(file, encoder);
+    measure();
+    if (!result || result.isEmpty() || encoder.isEmpty())
+      return;
+    const styles4 = ctx.decoder.clone().collect(encoder);
+    const css = ctx.getParserCss(styles4, file);
+    if (!css)
       return;
-    ctx.stylesheet.clean();
-    ctx.appendParserCss(result);
-    const css2 = ctx.stylesheet.toCss({ optimize: true, minify: false });
     if (options.dry) {
-      console.log({ path: file, ast: result, code: css2 });
+      console.log({ path: file, ast: result, code: css });
+      return;
     }
     if (outdir) {
       filesWithCss.push(file);
       const parsedPath = parse2(file);
-      const relative3 = path2.relative(ctx.config.cwd, parsedPath.dir);
-      const astJsonPath = `${relative3}/${parsedPath.name}.ast.json`.replaceAll(path2.sep, "__");
-      const cssPath = `${relative3}/${parsedPath.name}.css`.replaceAll(path2.sep, "__");
-      logger7.info("cli", `Writing ${colors.bold(`${outdir}/${astJsonPath}`)}`);
-      logger7.info("cli", `Writing ${colors.bold(`${outdir}/${cssPath}`)}`);
+      const relative2 = path.relative(ctx.config.cwd, parsedPath.dir);
+      const astJsonPath = `${relative2}/${parsedPath.name}.ast.json`.replaceAll(path.sep, "__");
+      const cssPath = `${relative2}/${parsedPath.name}.css`.replaceAll(path.sep, "__");
+      logger8.info("cli", `Writing ${colors2.bold(`${outdir}/${astJsonPath}`)}`);
+      logger8.info("cli", `Writing ${colors2.bold(`${outdir}/${cssPath}`)}`);
       return Promise.allSettled([
         fs.writeFile(`${outdir}/${astJsonPath}`, JSON.stringify(result.toJSON(), null, 2)),
-        fs.writeFile(`${outdir}/${cssPath}`, css2)
+        fs.writeFile(`${outdir}/${cssPath}`, css)
       ]);
     }
   });
-  logger7.info("cli", `Found ${colors.bold(`${filesWithCss.length}/${files.length}`)} files using Panda`);
+  logger8.info("cli", `Found ${colors2.bold(`${filesWithCss.length}/${files.length}`)} files using Panda`);
   measureTotal();
 }
 
-// src/exec-command.ts
-init_esm_shims();
-import { logger as logger8 } from "@pandacss/logger";
-import { spawnSync } from "child_process";
-import getPackageManager from "preferred-pm";
-async function execCommand(cmd, cwd) {
-  const manager = await getPackageManager(cwd);
-  const pm = manager?.name ?? "npm";
-  const args = cmd.split(" ");
-  if (pm === "npm") {
-    args.unshift("run");
-  }
-  const check = spawnSync(pm, args, { cwd, stdio: "pipe" });
-  if (check.status !== 0) {
-    logger8.error("exec", check.stderr.toString());
-  }
-}
-
 // src/generate.ts
 init_esm_shims();
 import { logger as logger9 } from "@pandacss/logger";
 import { match } from "ts-pattern";
-async function build(ctx, ids) {
-  await emitArtifacts(ctx, ids);
+async function build(ctx, artifactIds) {
+  await codegen(ctx, artifactIds);
   if (ctx.config.emitTokensOnly) {
     return logger9.info("css:emit", "Successfully rebuilt the css variables and js function to query your tokens \u2728");
   }
-  ctx.appendAllCss();
-  await ctx.writeCss();
+  const sheet = ctx.createSheet();
+  ctx.appendLayerParams(sheet);
+  ctx.appendBaselineCss(sheet);
+  ctx.parseFiles();
+  ctx.appendParserCss(sheet);
+  await ctx.writeCss(sheet);
   logger9.info("css:emit", "Successfully built the css files \u2728");
 }
 async function generate(config, configPath) {
   let ctx = await loadConfigAndCreateContext({ config, configPath });
   await build(ctx);
   const {
-    runtime: { fs, path: path2 },
+    runtime: { fs, path },
     config: { cwd }
   } = ctx;
   if (ctx.config.watch) {
@@ -2848,27 +2832,39 @@ async function generate(config, configPath) {
       const affecteds = await ctx.diff.reloadConfigAndRefreshContext((conf) => {
         ctx = new PandaContext({ ...conf, hooks: ctx.hooks });
       });
-      if (!affecteds.artifacts.size)
+      if (!affecteds.hasConfigChanged) {
+        logger9.debug("builder", "Config didnt change, skipping rebuild");
         return;
+      }
       logger9.info("config:change", "Config changed, restarting...");
       await ctx.hooks.callHook("config:change", ctx.config);
       return build(ctx, Array.from(affecteds.artifacts));
     });
     const contentWatcher = fs.watch(ctx.config);
+    const bundleStyles = async (ctx2, changedFilePath) => {
+      const outfile = ctx2.runtime.path.join(...ctx2.paths.root, "styles.css");
+      const parserResult = ctx2.project.parseSourceFile(changedFilePath);
+      if (parserResult) {
+        const sheet = ctx2.createSheet();
+        ctx2.appendLayerParams(sheet);
+        ctx2.appendBaselineCss(sheet);
+        ctx2.appendParserCss(sheet);
+        const css = ctx2.getCss(sheet);
+        await ctx2.runtime.fs.writeFile(outfile, css);
+        return { msg: ctx2.messages.buildComplete(1) };
+      }
+    };
     contentWatcher.on("all", async (event, file) => {
       logger9.info(`file:${event}`, file);
-      await match(event).with("unlink", () => {
-        ctx.project.removeSourceFile(path2.abs(cwd, file));
-      }).with("change", () => {
+      const filePath = path.abs(cwd, file);
+      match(event).with("unlink", () => {
+        ctx.project.removeSourceFile(path.abs(cwd, file));
+      }).with("change", async () => {
         ctx.project.reloadSourceFile(file);
-        const result = ctx.project.parseSourceFile(file);
-        ctx.appendParserCss(result);
-        return ctx.writeCss();
-      }).with("add", () => {
+        return bundleStyles(ctx, filePath);
+      }).with("add", async () => {
         ctx.project.createSourceFile(file);
-        const result = ctx.project.parseSourceFile(file);
-        ctx.appendParserCss(result);
-        return ctx.writeCss();
+        return bundleStyles(ctx, filePath);
       }).otherwise(() => {
       });
     });
@@ -2879,7 +2875,7 @@ async function generate(config, configPath) {
 // src/git-ignore.ts
 init_esm_shims();
 import { appendFileSync, readFileSync, writeFileSync } from "fs";
-import { lookItUpSync as lookItUpSync2 } from "look-it-up";
+import { lookItUpSync } from "look-it-up";
 import outdent from "outdent";
 function setupGitIgnore(ctx) {
   const { outdir, gitignore } = ctx.config;
@@ -2891,7 +2887,7 @@ function setupGitIgnore(ctx) {
   ${outdir}
   ${ctx.studio.outdir}
   `;
-  const file = lookItUpSync2(".gitignore");
+  const file = lookItUpSync(".gitignore");
   if (!file) {
     return writeFileSync(".gitignore", txt);
   }
@@ -2903,21 +2899,22 @@ function setupGitIgnore(ctx) {
 
 // src/setup-config.ts
 init_esm_shims();
+import { findConfig as findConfig2 } from "@pandacss/config";
 import { messages } from "@pandacss/generator";
 import { logger as logger10, quote } from "@pandacss/logger";
-import fsExtra3 from "fs-extra";
-import { lookItUpSync as lookItUpSync3 } from "look-it-up";
+import fsExtra2 from "fs-extra";
+import { lookItUpSync as lookItUpSync2 } from "look-it-up";
 import { outdent as outdent2 } from "outdent";
 import { join as join2 } from "pathe";
-import getPackageManager2 from "preferred-pm";
+import getPackageManager from "preferred-pm";
 import prettier from "prettier";
 async function setupConfig(cwd, opts = {}) {
   const { force, outExtension, jsxFramework, syntax } = opts;
-  const configFile = findConfig();
-  const pmResult = await getPackageManager2(cwd);
+  const configFile = findConfig2({ cwd });
+  const pmResult = await getPackageManager(cwd);
   const pm = pmResult?.name ?? "npm";
   const cmd = pm === "npm" ? "npm run" : pm;
-  const isTs = lookItUpSync3("tsconfig.json", cwd);
+  const isTs = lookItUpSync2("tsconfig.json", cwd);
   const file = isTs ? "panda.config.ts" : "panda.config.mjs";
   logger10.info("init:config", `creating panda config file: ${quote(file)}`);
   if (!force && configFile) {
@@ -2953,7 +2950,7 @@ jsxFramework: '${jsxFramework}',` : ""}
 syntax: '${syntax}'` : ""}
 })
     `;
-    await fsExtra3.writeFile(join2(cwd, file), prettier.format(content));
+    await fsExtra2.writeFile(join2(cwd, file), prettier.format(content));
     logger10.log(messages.thankYou());
   }
 }
@@ -2966,50 +2963,21 @@ module.exports = {
   },
 }
   `;
-  await fsExtra3.writeFile(join2(cwd, "postcss.config.cjs"), content);
-}
-
-// src/ship-files.ts
-init_esm_shims();
-import { colors as colors2, logger as logger11 } from "@pandacss/logger";
-import { createParserResult as createParserResult2 } from "@pandacss/parser";
-import { writeFile as writeFile2 } from "fs/promises";
-import * as path from "pathe";
-async function shipFiles(ctx, outfile) {
-  const files = ctx.getFiles();
-  const extractResult = createParserResult2();
-  const filesWithCss = [];
-  files.forEach(async (file) => {
-    const result = ctx.project.parseSourceFile(file);
-    if (!result || result.isEmpty())
-      return;
-    extractResult.merge(result);
-    filesWithCss.push(path.relative(ctx.config.cwd, file));
-  });
-  logger11.info("cli", `Found ${colors2.bold(`${filesWithCss.length}/${files.length}`)} files using Panda`);
-  const minify = ctx.config.minify;
-  logger11.info("cli", `Writing ${minify ? "[min] " : " "}${colors2.bold(outfile)}`);
-  const output = JSON.stringify(extractResult.toJSON(), null, minify ? 0 : 2);
-  const dirname2 = ctx.runtime.path.dirname(outfile);
-  ctx.runtime.fs.ensureDirSync(dirname2);
-  await writeFile2(outfile, output);
-  logger11.info("cli", "Done!");
+  await fsExtra2.writeFile(join2(cwd, "postcss.config.cjs"), content);
 }
 export {
   Builder,
   PandaContext,
   analyzeTokens,
-  debugFiles,
-  emitArtifacts,
-  execCommand,
-  extractFile,
-  findConfig,
+  buildInfo,
+  codegen,
+  cssgen,
+  debug,
   generate,
   loadConfigAndCreateContext,
   parseDependency,
   setupConfig,
   setupGitIgnore,
   setupPostcss,
-  shipFiles,
   writeAnalyzeJSON
 };