@pandacss/node 0.23.0 → 0.24.1

package/dist/index.js

@@ -11,9 +11,9 @@ var __esm = (fn, res) => function __init() {
 var __commonJS = (cb, mod) => function __require() {
   return mod || (0, cb[__getOwnPropNames(cb)[0]])((mod = { exports: {} }).exports, mod), mod.exports;
 };
-var __export = (target, all2) => {
-  for (var name in all2)
-    __defProp(target, name, { get: all2[name], enumerable: true });
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
 };
 var __copyProps = (to, from, except, desc) => {
   if (from && typeof from === "object" || typeof from === "function") {
@@ -33,9 +33,9 @@ var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__ge
 ));
 var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
 
-// ../../node_modules/.pnpm/tsup@7.1.0_typescript@5.3.3/node_modules/tsup/assets/cjs_shims.js
+// ../../node_modules/.pnpm/tsup@8.0.1_typescript@5.3.3/node_modules/tsup/assets/cjs_shims.js
 var init_cjs_shims = __esm({
-  "../../node_modules/.pnpm/tsup@7.1.0_typescript@5.3.3/node_modules/tsup/assets/cjs_shims.js"() {
+  "../../node_modules/.pnpm/tsup@8.0.1_typescript@5.3.3/node_modules/tsup/assets/cjs_shims.js"() {
     "use strict";
   }
 });
@@ -406,18 +406,16 @@ __export(src_exports, {
   Builder: () => Builder,
   PandaContext: () => PandaContext,
   analyzeTokens: () => analyzeTokens,
-  debugFiles: () => debugFiles,
-  emitArtifacts: () => emitArtifacts,
-  execCommand: () => execCommand,
-  extractFile: () => extractFile,
-  findConfig: () => findConfig,
+  buildInfo: () => buildInfo,
+  codegen: () => codegen,
+  cssgen: () => cssgen,
+  debug: () => debug,
   generate: () => generate,
   loadConfigAndCreateContext: () => loadConfigAndCreateContext,
   parseDependency: () => parseDependency,
   setupConfig: () => setupConfig,
   setupGitIgnore: () => setupGitIgnore,
   setupPostcss: () => setupPostcss,
-  shipFiles: () => shipFiles,
   writeAnalyzeJSON: () => writeAnalyzeJSON
 });
 module.exports = __toCommonJS(src_exports);
@@ -714,7 +712,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();
@@ -728,11 +726,11 @@ function analyzeTokens(ctx, options = {}) {
         classify: classifyMs
       },
       fileSizes: {
-        lineCount: css2.split("\n").length,
-        normal: (0, import_filesize.filesize)(Buffer.byteLength(css2, "utf-8")),
+        lineCount: css.split("\n").length,
+        normal: (0, import_filesize.filesize)(Buffer.byteLength(css, "utf-8")),
         minified: (0, import_filesize.filesize)(Buffer.byteLength(minifiedCss, "utf-8")),
         gzip: {
-          normal: (0, import_filesize.filesize)(gzipSizeSync(css2)),
+          normal: (0, import_filesize.filesize)(gzipSizeSync(css)),
           minified: (0, import_filesize.filesize)(gzipSizeSync(minifiedCss))
         }
       }
@@ -772,13 +770,42 @@ var writeAnalyzeJSON = (filePath, result, ctx) => {
   );
 };
 
+// src/build-info.ts
+init_cjs_shims();
+var import_logger2 = require("@pandacss/logger");
+
+// package.json
+var version = "0.24.1";
+
+// src/build-info.ts
+async function buildInfo(ctx, outfile) {
+  const { filesWithCss, files } = ctx.parseFiles();
+  import_logger2.logger.info("cli", `Found ${import_logger2.colors.bold(`${filesWithCss.length}/${files.length}`)} files using Panda`);
+  const minify = ctx.config.minify;
+  import_logger2.logger.info("cli", `Writing ${minify ? "[min] " : " "}${import_logger2.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);
+  import_logger2.logger.info("cli", "Done!");
+}
+
 // src/builder.ts
 init_cjs_shims();
+var import_config3 = require("@pandacss/config");
 var import_core = require("@pandacss/core");
 var import_error = require("@pandacss/error");
 var import_logger6 = require("@pandacss/logger");
 var import_fs = require("fs");
-var import_fs_extra2 = __toESM(require("fs-extra"));
+
+// src/codegen.ts
+init_cjs_shims();
 
 // ../../node_modules/.pnpm/p-limit@4.0.0/node_modules/p-limit/index.js
 init_cjs_shims();
@@ -887,372 +914,6 @@ function pLimit(concurrency) {
   return generator;
 }
 
-// src/builder.ts
-var import_pathe3 = require("pathe");
-
-// src/config.ts
-init_cjs_shims();
-var import_config2 = require("@pandacss/config");
-var import_hookable = require("hookable");
-var import_look_it_up = require("look-it-up");
-var import_tsconfck = require("tsconfck");
-
-// src/create-context.ts
-init_cjs_shims();
-var import_generator2 = require("@pandacss/generator");
-var import_logger4 = require("@pandacss/logger");
-var import_parser = require("@pandacss/parser");
-
-// src/diff-engine.ts
-init_cjs_shims();
-var import_config = require("@pandacss/config");
-var import_generator = require("@pandacss/generator");
-var import_shared = require("@pandacss/shared");
-var import_microdiff = __toESM(require("microdiff"));
-
-// src/matcher.ts
-init_cjs_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 (0, import_config.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 = (0, import_microdiff.default)(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 = (0, import_shared.dashCase)(change.path.slice(1, 3).join("."));
-          affected.artifacts.add(name);
-        }
-        if (id === "patterns") {
-          const name = (0, import_shared.dashCase)(change.path.slice(0, 2).join("."));
-          affected.artifacts.add(name);
-        }
-        affected.artifacts.add(id);
-      });
-    });
-    return affected;
-  }
-};
-
-// src/node-runtime.ts
-init_cjs_shims();
-var import_logger2 = require("@pandacss/logger");
-var import_chokidar = __toESM(require("chokidar"));
-var import_fast_glob = __toESM(require("fast-glob"));
-var import_fs_extra = __toESM(require("fs-extra"));
-var import_pathe = require("pathe");
-var nodeRuntime = {
-  cwd() {
-    return process.cwd();
-  },
-  env(name) {
-    return process.env[name];
-  },
-  path: {
-    join: import_pathe.join,
-    relative: import_pathe.relative,
-    dirname: import_pathe.dirname,
-    extname: import_pathe.extname,
-    isAbsolute: import_pathe.isAbsolute,
-    sep: import_pathe.sep,
-    abs(cwd, str) {
-      return (0, import_pathe.isAbsolute)(str) ? str : (0, import_pathe.join)(cwd, str);
-    }
-  },
-  fs: {
-    existsSync: import_fs_extra.default.existsSync,
-    readFileSync(filePath) {
-      return import_fs_extra.default.readFileSync(filePath, "utf8");
-    },
-    glob(opts) {
-      if (!opts.include)
-        return [];
-      const ignore = opts.exclude ?? [];
-      if (!ignore.length) {
-        ignore.push("**/*.d.ts");
-      }
-      return import_fast_glob.default.sync(opts.include, { cwd: opts.cwd, ignore, absolute: true });
-    },
-    writeFile: import_fs_extra.default.writeFile,
-    writeFileSync: import_fs_extra.default.writeFileSync,
-    readDirSync: import_fs_extra.default.readdirSync,
-    rmDirSync: import_fs_extra.default.emptyDirSync,
-    rmFileSync: import_fs_extra.default.removeSync,
-    ensureDirSync(path2) {
-      return import_fs_extra.default.ensureDirSync(path2);
-    },
-    watch(options) {
-      const { include, exclude, cwd, poll } = options;
-      const coalesce = poll || process.platform === "win32";
-      const watcher = import_chokidar.default.watch(include, {
-        usePolling: poll,
-        cwd,
-        ignoreInitial: true,
-        ignorePermissionErrors: true,
-        ignored: exclude,
-        awaitWriteFinish: coalesce ? { stabilityThreshold: 50, pollInterval: 10 } : false
-      });
-      import_logger2.logger.debug("watch:file", `watching [${include}]`);
-      process.once("SIGINT", async () => {
-        await watcher.close();
-      });
-      return watcher;
-    }
-  }
-};
-process.setMaxListeners(Infinity);
-process.on("unhandledRejection", (reason) => {
-  import_logger2.logger.error("\u274C", reason);
-});
-process.on("uncaughtException", (reason) => {
-  import_logger2.logger.error("\u274C", reason);
-});
-
-// src/output-engine.ts
-init_cjs_shims();
-var import_logger3 = require("@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);
-        import_logger3.logger.debug("write:file", dir.slice(-1).concat(file).join("/"));
-        return this.fs.writeFile(absPath, code);
-      })
-    );
-  }
-};
-
-// src/create-context.ts
-var PandaContext = class extends import_generator2.Generator {
-  runtime;
-  project;
-  getFiles;
-  output;
-  diff;
-  constructor(conf) {
-    super(conf);
-    const config = conf.config;
-    this.runtime = nodeRuntime;
-    config.cwd ||= this.runtime.cwd();
-    if (config.logLevel) {
-      import_logger4.logger.level = config.logLevel;
-    }
-    const { include, exclude, cwd } = config;
-    this.getFiles = () => this.runtime.fs.glob({ include, exclude, cwd });
-    this.project = (0, import_parser.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 = (0, import_parser.createParserResult)();
-    files.forEach((file) => {
-      const measure = import_logger4.logger.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 = (0, import_look_it_up.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 (0, import_config2.loadConfigFile)({ cwd, file: configPath });
-  if (config) {
-    Object.assign(conf.config, config);
-  }
-  if (options.cwd) {
-    conf.config.cwd = options.cwd;
-  }
-  const tsconfigResult = await (0, import_tsconfck.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: (0, import_config2.convertTsPathsToRegexes)(options2.paths, baseUrl ?? cwd)
-      };
-    }
-  }
-  conf.config.outdir ??= "styled-system";
-  const hooks = (0, import_hookable.createHooks)();
-  if (conf.config.hooks) {
-    hooks.addHooks(conf.config.hooks);
-  }
-  await hooks.callHook("config:resolved", conf);
-  if (conf.config.logLevel === "debug") {
-    (0, import_hookable.createDebugger)(hooks, { tag: "panda" });
-  }
-  return new PandaContext({ ...conf, hooks });
-}
-
-// src/emit-artifact.ts
-init_cjs_shims();
-
 // src/cli-box.ts
 init_cjs_shims();
 
@@ -1610,10 +1271,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;
@@ -2565,11 +2226,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)));
@@ -2584,22 +2245,312 @@ async function emitArtifacts(ctx, ids) {
   };
 }
 
-// src/extract.ts
+// src/config.ts
 init_cjs_shims();
-var import_logger5 = require("@pandacss/logger");
-function extractFile(ctx, filePath) {
-  const file = ctx.runtime.path.abs(ctx.config.cwd, filePath);
-  import_logger5.logger.debug("file:extract", file);
-  const measure = import_logger5.logger.time.debug(`Extracted ${file}`);
-  let result;
-  try {
-    result = ctx.project.parseSourceFile(file);
-  } catch (error) {
-    import_logger5.logger.error("file:parse", error);
-  }
-  ctx.appendParserCss(result);
-  measure();
-  return result;
+var import_config2 = require("@pandacss/config");
+var import_hookable = require("hookable");
+var import_tsconfck = require("tsconfck");
+
+// src/create-context.ts
+init_cjs_shims();
+var import_generator2 = require("@pandacss/generator");
+var import_logger5 = require("@pandacss/logger");
+var import_parser = require("@pandacss/parser");
+var import_perfect_debounce = require("perfect-debounce");
+
+// src/diff-engine.ts
+init_cjs_shims();
+var import_config = require("@pandacss/config");
+var import_generator = require("@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 (0, import_config.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 = (0, import_config.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_cjs_shims();
+var import_logger3 = require("@pandacss/logger");
+var import_chokidar = __toESM(require("chokidar"));
+var import_fast_glob = __toESM(require("fast-glob"));
+var import_fs_extra = __toESM(require("fs-extra"));
+var import_pathe = require("pathe");
+var nodeRuntime = {
+  cwd() {
+    return process.cwd();
+  },
+  env(name) {
+    return process.env[name];
+  },
+  path: {
+    join: import_pathe.join,
+    relative: import_pathe.relative,
+    dirname: import_pathe.dirname,
+    extname: import_pathe.extname,
+    isAbsolute: import_pathe.isAbsolute,
+    sep: import_pathe.sep,
+    resolve: import_pathe.resolve,
+    abs(cwd, str) {
+      return (0, import_pathe.isAbsolute)(str) ? str : (0, import_pathe.join)(cwd, str);
+    }
+  },
+  fs: {
+    existsSync: import_fs_extra.default.existsSync,
+    readFileSync(filePath) {
+      return import_fs_extra.default.readFileSync(filePath, "utf8");
+    },
+    glob(opts) {
+      if (!opts.include)
+        return [];
+      const ignore = opts.exclude ?? [];
+      if (!ignore.length) {
+        ignore.push("**/*.d.ts");
+      }
+      return import_fast_glob.default.sync(opts.include, { cwd: opts.cwd, ignore, absolute: true });
+    },
+    writeFile: import_fs_extra.default.writeFile,
+    writeFileSync: import_fs_extra.default.writeFileSync,
+    readDirSync: import_fs_extra.default.readdirSync,
+    rmDirSync: import_fs_extra.default.emptyDirSync,
+    rmFileSync: import_fs_extra.default.removeSync,
+    ensureDirSync(path) {
+      return import_fs_extra.default.ensureDirSync(path);
+    },
+    watch(options) {
+      const { include, exclude, cwd, poll } = options;
+      const coalesce = poll || process.platform === "win32";
+      const watcher = import_chokidar.default.watch(include, {
+        usePolling: poll,
+        cwd,
+        ignoreInitial: true,
+        ignorePermissionErrors: true,
+        ignored: exclude,
+        awaitWriteFinish: coalesce ? { stabilityThreshold: 50, pollInterval: 10 } : false
+      });
+      import_logger3.logger.debug("watch:file", `watching [${include}]`);
+      process.once("SIGINT", async () => {
+        await watcher.close();
+      });
+      return watcher;
+    }
+  }
+};
+process.setMaxListeners(Infinity);
+process.on("unhandledRejection", (reason) => {
+  import_logger3.logger.error("\u274C", reason);
+});
+process.on("uncaughtException", (reason) => {
+  import_logger3.logger.error("\u274C", reason);
+});
+
+// src/output-engine.ts
+init_cjs_shims();
+var import_logger4 = require("@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);
+        import_logger4.logger.debug("write:file", dir.slice(-1).concat(file).join("/"));
+        return this.fs.writeFile(absPath, code);
+      })
+    );
+  };
+};
+
+// src/create-context.ts
+var PandaContext = class extends import_generator2.Generator {
+  runtime;
+  project;
+  output;
+  diff;
+  constructor(conf) {
+    super(conf);
+    const config = conf.config;
+    this.runtime = nodeRuntime;
+    config.cwd ||= this.runtime.cwd();
+    if (config.logLevel) {
+      import_logger5.logger.level = config.logLevel;
+    }
+    this.project = new import_parser.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);
+    import_logger5.logger.debug("file:extract", file);
+    const measure = import_logger5.logger.time.debug(`Parsed ${file}`);
+    let result;
+    try {
+      const encoder = styleEncoder || this.parserOptions.encoder;
+      result = this.project.parseSourceFile(file, encoder);
+    } catch (error) {
+      import_logger5.logger.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 = import_logger5.logger.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 ?? {};
+    import_logger5.logger.info("ctx:watch", this.messages.configWatch());
+    const watcher = this.runtime.fs.watch({
+      include: this.conf.dependencies,
+      exclude,
+      cwd,
+      poll
+    });
+    watcher.on(
+      "change",
+      (0, import_perfect_debounce.debounce)(async () => {
+        import_logger5.logger.info("ctx:change", "config changed, rebuilding...");
+        await cb();
+      })
+    );
+  };
+  watchFiles = (cb) => {
+    const { include, exclude, poll, cwd } = this.config;
+    import_logger5.logger.info("ctx:watch", this.messages.watch());
+    const watcher = this.runtime.fs.watch({
+      include,
+      exclude,
+      poll,
+      cwd
+    });
+    watcher.on(
+      "all",
+      (0, import_perfect_debounce.debounce)(async (event, file) => {
+        import_logger5.logger.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 (0, import_config2.loadConfig)({ cwd, file: configPath });
+  if (config) {
+    Object.assign(conf.config, config);
+  }
+  if (options.cwd) {
+    conf.config.cwd = options.cwd;
+  }
+  const tsconfigResult = await (0, import_tsconfck.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: (0, import_config2.convertTsPathsToRegexes)(options2.paths, baseUrl ?? cwd)
+      };
+    }
+  }
+  conf.config.outdir ??= "styled-system";
+  const hooks = (0, import_hookable.createHooks)();
+  if (conf.config.hooks) {
+    hooks.addHooks(conf.config.hooks);
+  }
+  await hooks.callHook("config:resolved", conf);
+  if (conf.config.logLevel === "debug") {
+    (0, import_hookable.createDebugger)(hooks, { tag: "panda" });
+  }
+  return new PandaContext({ ...conf, hooks });
 }
 
 // src/parse-dependency.ts
@@ -2647,19 +2598,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;
-  hasFilesChanged = true;
+  filesMeta;
   affecteds;
-  getConfigPath = () => {
-    const configPath = findConfig();
+  getConfigPath = (cwd) => {
+    const configPath = (0, import_config3.findConfig)({ cwd });
     if (!configPath) {
       throw new import_error.ConfigNotFoundError();
     }
@@ -2667,14 +2616,13 @@ var Builder = class {
   };
   setup = async (options = {}) => {
     import_logger6.logger.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();
     });
     import_logger6.logger.debug("builder", this.affecteds);
     if (this.affecteds.hasConfigChanged) {
@@ -2682,8 +2630,8 @@ var Builder = class {
       await ctx.hooks.callHook("config:change", ctx.config);
       return;
     }
-    this.hasFilesChanged = this.checkFilesChanged(ctx.getFiles());
-    if (this.hasFilesChanged) {
+    this.filesMeta = this.checkFilesChanged(ctx.getFiles());
+    if (this.filesMeta.hasFilesChanged) {
       import_logger6.logger.debug("builder", "Files changed, invalidating them");
       ctx.project.reloadSourceFiles();
     }
@@ -2691,14 +2639,13 @@ var Builder = class {
   async emit() {
     if (this.hasEmitted && this.affecteds?.hasConfigChanged) {
       import_logger6.logger.debug("builder", "Emit artifacts after config change");
-      await emitArtifacts(this.getContextOrThrow(), Array.from(this.affecteds.artifacts));
+      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;
   };
@@ -2709,48 +2656,48 @@ var Builder = class {
     return this.context;
   };
   getFileMeta = (file) => {
-    const mtime = (0, import_fs.existsSync)(file) ? import_fs_extra2.default.statSync(file).mtimeMs : -Infinity;
+    const mtime = (0, import_fs.existsSync)(file) ? (0, import_fs.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 && this.affecteds?.hasConfigChanged) {
-      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.hasFilesChanged && !hasConfigChanged) {
+    if (!this.filesMeta && !hasConfigChanged) {
       import_logger6.logger.debug("builder", "No files or config changed, skipping extract");
       return;
     }
     const ctx = this.getContextOrThrow();
     const files = ctx.getFiles();
     const done = import_logger6.logger.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;
       }
     });
@@ -2762,12 +2709,17 @@ var Builder = class {
       this.initialRoot = root.toString();
     }
     root.removeAll();
-    const css2 = this.toString();
-    const newCss = (0, import_core.optimizeCss)(`
+    const ctx = this.getContextOrThrow();
+    const sheet = ctx.createSheet();
+    ctx.appendBaselineCss(sheet);
+    ctx.appendParserCss(sheet);
+    const css = ctx.getCss(sheet);
+    root.append(
+      (0, import_core.optimizeCss)(`
     ${this.initialRoot}
-    ${css2}
-    `);
-    root.append(newCss);
+    ${css}
+    `)
+    );
   };
   registerDependency = (fn) => {
     const ctx = this.getContextOrThrow();
@@ -2778,98 +2730,126 @@ var Builder = class {
       }
     }
     for (const file of ctx.conf.dependencies) {
-      fn({ type: "dependency", file: (0, import_pathe3.resolve)(file) });
+      fn({ type: "dependency", file: ctx.runtime.path.resolve(file) });
     }
   };
 };
 
-// src/debug-files.ts
+// src/cssgen.ts
 init_cjs_shims();
 var import_logger7 = require("@pandacss/logger");
-var import_pathe4 = require("pathe");
-async function debugFiles(ctx, options) {
+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);
+    import_logger7.logger.info("css:emit:path", outPath);
+    import_logger7.logger.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);
+    import_logger7.logger.info("css:emit:path", outPath);
+    import_logger7.logger.info("css:emit:out", msg);
+  }
+};
+
+// src/debug.ts
+init_cjs_shims();
+var import_logger8 = require("@pandacss/logger");
+var import_pathe3 = require("pathe");
+async function debug(ctx, options) {
   const files = ctx.getFiles();
-  const measureTotal = import_logger7.logger.time.debug(`Done parsing ${files.length} files`);
-  const { fs, path: path2 } = ctx.runtime;
+  const measureTotal = import_logger8.logger.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);
-    import_logger7.logger.info("cli", `Writing ${import_logger7.colors.bold(`${outdir}/config.json`)}`);
+    import_logger8.logger.info("cli", `Writing ${import_logger8.colors.bold(`${outdir}/config.json`)}`);
     await fs.writeFile(`${outdir}/config.json`, JSON.stringify(ctx.config, null, 2));
   }
   if (options.onlyConfig) {
     measureTotal();
     return;
   }
-  const results = await Promise.all(
-    files.map(async (file) => {
-      const measure = import_logger7.logger.time.debug(`Parsed ${file}`);
-      const result = ctx.project.parseSourceFile(file);
-      measure();
-      return { file, result };
-    })
-  );
-  const filteredResults = results.filter(({ result }) => result && !result.isEmpty());
-  filteredResults.forEach(({ file, result }) => {
-    ctx.stylesheet.clean();
-    ctx.appendParserCss(result);
-    const css2 = ctx.stylesheet.toCss({ optimize: true, minify: false });
+  const filesWithCss = [];
+  files.map((file) => {
+    const measure = import_logger8.logger.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;
     if (options.dry) {
-      console.log({ path: file, ast: result, code: css2 });
+      console.log({ path: file, ast: result, code: css });
+      return;
     }
     if (outdir) {
-      const parsedPath = (0, import_pathe4.parse)(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, "__");
-      import_logger7.logger.info("cli", `Writing ${import_logger7.colors.bold(`${outdir}/${astJsonPath}`)}`);
-      import_logger7.logger.info("cli", `Writing ${import_logger7.colors.bold(`${outdir}/${cssPath}`)}`);
+      filesWithCss.push(file);
+      const parsedPath = (0, import_pathe3.parse)(file);
+      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, "__");
+      import_logger8.logger.info("cli", `Writing ${import_logger8.colors.bold(`${outdir}/${astJsonPath}`)}`);
+      import_logger8.logger.info("cli", `Writing ${import_logger8.colors.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)
       ]);
     }
   });
-  import_logger7.logger.info("cli", `Found ${import_logger7.colors.bold(`${filteredResults.length}/${files.length}`)} files using Panda`);
+  import_logger8.logger.info("cli", `Found ${import_logger8.colors.bold(`${filesWithCss.length}/${files.length}`)} files using Panda`);
   measureTotal();
 }
 
-// src/exec-command.ts
-init_cjs_shims();
-var import_logger8 = require("@pandacss/logger");
-var import_child_process = require("child_process");
-var import_preferred_pm = __toESM(require("preferred-pm"));
-async function execCommand(cmd, cwd) {
-  const manager = await (0, import_preferred_pm.default)(cwd);
-  const pm = manager?.name ?? "npm";
-  const args = cmd.split(" ");
-  if (pm === "npm") {
-    args.unshift("run");
-  }
-  const check = (0, import_child_process.spawnSync)(pm, args, { cwd, stdio: "pipe" });
-  if (check.status !== 0) {
-    import_logger8.logger.error("exec", check.stderr.toString());
-  }
-}
-
 // src/generate.ts
 init_cjs_shims();
 var import_logger9 = require("@pandacss/logger");
 var import_ts_pattern = require("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 import_logger9.logger.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);
   import_logger9.logger.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) {
@@ -2878,27 +2858,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) {
+        import_logger9.logger.debug("builder", "Config didnt change, skipping rebuild");
         return;
+      }
       import_logger9.logger.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) => {
       import_logger9.logger.info(`file:${event}`, file);
-      await (0, import_ts_pattern.match)(event).with("unlink", () => {
-        ctx.project.removeSourceFile(path2.abs(cwd, file));
-      }).with("change", () => {
+      const filePath = path.abs(cwd, file);
+      (0, import_ts_pattern.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(() => {
       });
     });
@@ -2909,7 +2901,7 @@ async function generate(config, configPath) {
 // src/git-ignore.ts
 init_cjs_shims();
 var import_fs2 = require("fs");
-var import_look_it_up2 = require("look-it-up");
+var import_look_it_up = require("look-it-up");
 var import_outdent = __toESM(require("outdent"));
 function setupGitIgnore(ctx) {
   const { outdir, gitignore } = ctx.config;
@@ -2921,7 +2913,7 @@ function setupGitIgnore(ctx) {
   ${outdir}
   ${ctx.studio.outdir}
   `;
-  const file = (0, import_look_it_up2.lookItUpSync)(".gitignore");
+  const file = (0, import_look_it_up.lookItUpSync)(".gitignore");
   if (!file) {
     return (0, import_fs2.writeFileSync)(".gitignore", txt);
   }
@@ -2933,21 +2925,22 @@ function setupGitIgnore(ctx) {
 
 // src/setup-config.ts
 init_cjs_shims();
+var import_config6 = require("@pandacss/config");
 var import_generator3 = require("@pandacss/generator");
 var import_logger10 = require("@pandacss/logger");
-var import_fs_extra3 = __toESM(require("fs-extra"));
-var import_look_it_up3 = require("look-it-up");
+var import_fs_extra2 = __toESM(require("fs-extra"));
+var import_look_it_up2 = require("look-it-up");
 var import_outdent2 = require("outdent");
-var import_pathe5 = require("pathe");
-var import_preferred_pm2 = __toESM(require("preferred-pm"));
+var import_pathe4 = require("pathe");
+var import_preferred_pm = __toESM(require("preferred-pm"));
 var import_prettier = __toESM(require("prettier"));
 async function setupConfig(cwd, opts = {}) {
   const { force, outExtension, jsxFramework, syntax } = opts;
-  const configFile = findConfig();
-  const pmResult = await (0, import_preferred_pm2.default)(cwd);
+  const configFile = (0, import_config6.findConfig)({ cwd });
+  const pmResult = await (0, import_preferred_pm.default)(cwd);
   const pm = pmResult?.name ?? "npm";
   const cmd = pm === "npm" ? "npm run" : pm;
-  const isTs = (0, import_look_it_up3.lookItUpSync)("tsconfig.json", cwd);
+  const isTs = (0, import_look_it_up2.lookItUpSync)("tsconfig.json", cwd);
   const file = isTs ? "panda.config.ts" : "panda.config.mjs";
   import_logger10.logger.info("init:config", `creating panda config file: ${(0, import_logger10.quote)(file)}`);
   if (!force && configFile) {
@@ -2983,7 +2976,7 @@ jsxFramework: '${jsxFramework}',` : ""}
 syntax: '${syntax}'` : ""}
 })
     `;
-    await import_fs_extra3.default.writeFile((0, import_pathe5.join)(cwd, file), import_prettier.default.format(content));
+    await import_fs_extra2.default.writeFile((0, import_pathe4.join)(cwd, file), import_prettier.default.format(content));
     import_logger10.logger.log(import_generator3.messages.thankYou());
   }
 }
@@ -2996,51 +2989,22 @@ module.exports = {
   },
 }
   `;
-  await import_fs_extra3.default.writeFile((0, import_pathe5.join)(cwd, "postcss.config.cjs"), content);
-}
-
-// src/ship-files.ts
-init_cjs_shims();
-var import_logger11 = require("@pandacss/logger");
-var import_parser2 = require("@pandacss/parser");
-var import_promises2 = require("fs/promises");
-var path = __toESM(require("pathe"));
-async function shipFiles(ctx, outfile) {
-  const files = ctx.getFiles();
-  const extractResult = (0, import_parser2.createParserResult)();
-  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));
-  });
-  import_logger11.logger.info("cli", `Found ${import_logger11.colors.bold(`${filesWithCss.length}/${files.length}`)} files using Panda`);
-  const minify = ctx.config.minify;
-  import_logger11.logger.info("cli", `Writing ${minify ? "[min] " : " "}${import_logger11.colors.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 (0, import_promises2.writeFile)(outfile, output);
-  import_logger11.logger.info("cli", "Done!");
+  await import_fs_extra2.default.writeFile((0, import_pathe4.join)(cwd, "postcss.config.cjs"), content);
 }
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
   Builder,
   PandaContext,
   analyzeTokens,
-  debugFiles,
-  emitArtifacts,
-  execCommand,
-  extractFile,
-  findConfig,
+  buildInfo,
+  codegen,
+  cssgen,
+  debug,
   generate,
   loadConfigAndCreateContext,
   parseDependency,
   setupConfig,
   setupGitIgnore,
   setupPostcss,
-  shipFiles,
   writeAnalyzeJSON
 });