@pandacss/config 2.1.1 → 2.1.2

package/dist/import-meta-url-SQ7JCEJ3.js

@@ -0,0 +1,34 @@
+// src/import-meta-url.ts
+import { parse } from "acorn";
+import { simple } from "acorn-walk";
+import MagicString from "magic-string";
+function replaceImportMetaUrl(code, replacement) {
+  const ast = parse(code, {
+    ecmaVersion: "latest",
+    sourceType: "module"
+  });
+  const output = new MagicString(code);
+  let changed = false;
+  simple(ast, {
+    MemberExpression(node) {
+      if (!isImportMetaUrl(node)) return;
+      output.overwrite(node.start, node.end, replacement);
+      changed = true;
+    }
+  });
+  return changed ? output.toString() : code;
+}
+function isImportMetaUrl(node) {
+  if (node.computed || !isIdentifier(node.property, "url")) return false;
+  const object = node.object;
+  return isNode(object, "MetaProperty") && isIdentifier(object.meta, "import") && isIdentifier(object.property, "meta");
+}
+function isIdentifier(value, name) {
+  return isNode(value, "Identifier") && value.name === name;
+}
+function isNode(value, type) {
+  return !!value && typeof value === "object" && value.type === type;
+}
+export {
+  replaceImportMetaUrl
+};

package/dist/index.d.ts

@@ -53,7 +53,7 @@ interface DesignSystemArtifactConflict {
     patterns: string[];
 }
 declare function collectArtifactConflicts(metadata: DesignSystemMetadata | undefined): DesignSystemArtifactConflict[];
-declare function collectExportMissingDiagnostics(metadata: DesignSystemMetadata | undefined): Diagnostic[];
+declare function collectExportMissingDiagnostics(metadata: DesignSystemMetadata | undefined, jsxFramework?: string): Diagnostic[];
 declare function collectNameCollisionDiagnostics(metadata: DesignSystemMetadata | undefined): Diagnostic[];
 
 interface LoadConfigOptions {

package/dist/index.js

@@ -21,24 +21,23 @@ import {
 import { applyConfigDefaults as applyConfigDefaults2 } from "@pandacss/compiler-shared";
 
 // src/bundle.ts
-import { existsSync, realpathSync } from "node:fs";
+import { existsSync as existsSync3, realpathSync, statSync as statSync2 } from "node:fs";
 import { mkdir, unlink, writeFile } from "node:fs/promises";
 import { builtinModules } from "node:module";
 import { tmpdir } from "node:os";
-import { basename, dirname, isAbsolute as isAbsolute2, join, normalize, relative } from "node:path";
-import { pathToFileURL as pathToFileURL2 } from "node:url";
+import { basename, dirname as dirname3, extname as extname2, isAbsolute as isAbsolute2, join as join3, normalize, relative, sep as sep2 } from "node:path";
+import { pathToFileURL as pathToFileURL3 } from "node:url";
+import { debuglog } from "node:util";
 
 // src/bundle-plugins.ts
-import { parse } from "acorn";
-import { simple } from "acorn-walk";
-import MagicString from "magic-string";
 import { isAbsolute } from "node:path";
 import { pathToFileURL } from "node:url";
 function importMetaUrlPlugin() {
   return {
     name: "panda-import-meta-url",
-    transform(code, id) {
+    async transform(code, id) {
       if (!isAbsolute(id) || !code.includes("import.meta.url")) return;
+      const { replaceImportMetaUrl } = await import("./import-meta-url-SQ7JCEJ3.js");
       const replacement = JSON.stringify(pathToFileURL(id).href);
       const patched = replaceImportMetaUrl(code, replacement);
       if (patched === code) return;
@@ -46,37 +45,193 @@ function importMetaUrlPlugin() {
     }
   };
 }
-function replaceImportMetaUrl(code, replacement) {
-  const ast = parse(code, {
-    ecmaVersion: "latest",
-    sourceType: "module"
+
+// src/resolve.ts
+import { existsSync, readFileSync } from "node:fs";
+import { createRequire } from "node:module";
+import { dirname, join, resolve } from "node:path";
+function tryResolveFrom(request, fromDir) {
+  try {
+    return createRequire(resolve(fromDir, "noop.js")).resolve(request, { paths: [fromDir] });
+  } catch (error) {
+    if (isResolveMiss(error)) return void 0;
+    throw error;
+  }
+}
+function isResolveMiss(error) {
+  const code = errorCode(error);
+  return code === "MODULE_NOT_FOUND" || code === "ERR_PACKAGE_PATH_NOT_EXPORTED";
+}
+function resolveFrom(request, fromDir) {
+  try {
+    return { kind: "resolved", path: createRequire(resolve(fromDir, "noop.js")).resolve(request, { paths: [fromDir] }) };
+  } catch (error) {
+    const code = errorCode(error);
+    if (code === "ERR_PACKAGE_PATH_NOT_EXPORTED") return { kind: "not-exported" };
+    if (code === "MODULE_NOT_FOUND") return { kind: "not-installed" };
+    throw error;
+  }
+}
+function errorCode(error) {
+  return typeof error === "object" && error !== null && "code" in error ? error.code : void 0;
+}
+function nearestPackageType(start) {
+  let current = start;
+  while (true) {
+    const candidate = join(current, "package.json");
+    if (existsSync(candidate)) return JSON.parse(readFileSync(candidate, "utf8")).type;
+    const parent = dirname(current);
+    if (parent === current) return void 0;
+    current = parent;
+  }
+}
+
+// src/transpile-loader.ts
+import { existsSync as existsSync2, readFileSync as readFileSync2, statSync } from "node:fs";
+import * as nodeModule from "node:module";
+import { dirname as dirname2, extname, join as join2, sep } from "node:path";
+import { fileURLToPath, pathToFileURL as pathToFileURL2 } from "node:url";
+var SESSION_PARAM = "panda-config";
+var TYPESCRIPT_EXTENSION = /\.[cm]?tsx?$/;
+var RESOLVE_EXTENSIONS = [".ts", ".tsx", ".mts", ".js", ".mjs"];
+var TranspileError = class extends Error {
+  name = "TranspileError";
+};
+var MODULE_LOAD_ERROR_CODES = /* @__PURE__ */ new Set([
+  "ERR_IMPORT_ATTRIBUTE_MISSING",
+  "ERR_IMPORT_ATTRIBUTE_TYPE_INCOMPATIBLE",
+  "ERR_IMPORT_ATTRIBUTE_UNSUPPORTED",
+  "ERR_INVALID_MODULE_SPECIFIER",
+  "ERR_INVALID_PACKAGE_CONFIG",
+  "ERR_INVALID_PACKAGE_TARGET",
+  "ERR_MODULE_NOT_FOUND",
+  "ERR_PACKAGE_IMPORT_NOT_DEFINED",
+  "ERR_PACKAGE_PATH_NOT_EXPORTED",
+  "ERR_REQUIRE_ASYNC_MODULE",
+  "ERR_REQUIRE_CYCLE_MODULE",
+  "ERR_REQUIRE_ESM",
+  "ERR_UNKNOWN_FILE_EXTENSION",
+  "ERR_UNKNOWN_MODULE_FORMAT",
+  "ERR_UNSUPPORTED_DIR_IMPORT",
+  "ERR_UNSUPPORTED_ESM_URL_SCHEME",
+  "MODULE_NOT_FOUND"
+]);
+var COMMONJS_GLOBAL_MISSING = /^(require|module|exports|__dirname|__filename) is not defined\b/;
+function isLoaderFailure(error) {
+  if (error instanceof TranspileError) return true;
+  const code = error?.code;
+  if (typeof code === "string" && MODULE_LOAD_ERROR_CODES.has(code)) return true;
+  if (error instanceof SyntaxError) return true;
+  return error instanceof ReferenceError && COMMONJS_GLOBAL_MISSING.test(error.message);
+}
+var sessions = /* @__PURE__ */ new Map();
+var commonjsFiles = /* @__PURE__ */ new Set();
+var requireCache = nodeModule.createRequire(import.meta.url).cache;
+var hooksRegistered;
+var nextSession = 0;
+function canTranspile(file) {
+  return typeof nodeModule.registerHooks === "function" && !/\.c[jt]s$/.test(file);
+}
+async function importTranspiled(file, evaluate) {
+  hooksRegistered ??= registerTranspileHooks();
+  await hooksRegistered.catch((cause) => {
+    throw new TranspileError("Could not register the transpile hooks.", { cause });
   });
-  const output = new MagicString(code);
-  let changed = false;
-  simple(ast, {
-    MemberExpression(node) {
-      if (!isImportMetaUrl(node)) return;
-      output.overwrite(node.start, node.end, replacement);
-      changed = true;
+  for (const commonjsFile of commonjsFiles) delete requireCache[commonjsFile];
+  const id = String(++nextSession);
+  const session = { files: /* @__PURE__ */ new Set([file]), loaded: false };
+  sessions.set(id, session);
+  try {
+    const mod = await import(
+      /* @vite-ignore */
+      withSession(pathToFileURL2(file).href, id)
+    );
+    if (!session.loaded) throw new TranspileError("Config was not loaded through the Panda transpile hooks.");
+    return { value: await evaluate(mod), files: Array.from(session.files) };
+  } finally {
+    sessions.delete(id);
+  }
+}
+async function registerTranspileHooks() {
+  const { transformSync } = await import("rolldown/utils");
+  nodeModule.registerHooks({
+    resolve(specifier, context, nextResolve) {
+      const id = sessionId(context.parentURL);
+      if (!id || !context.parentURL) return nextResolve(specifier, context);
+      const tag = (file) => {
+        sessions.get(id)?.files.add(file);
+        return { url: withSession(pathToFileURL2(file).href, id), shortCircuit: true };
+      };
+      if (isRelative(specifier)) {
+        const file = resolveRelative(specifier, context.parentURL);
+        return file ? tag(file) : nextResolve(specifier, context);
+      }
+      const resolved = nextResolve(specifier, context);
+      const linked = linkedPackageFile(resolved.url);
+      if (linked) return tag(linked);
+      if (isCommonJs(resolved)) {
+        throw new TranspileError(`${specifier} is CommonJS, so the bundler loads this config.`);
+      }
+      return resolved;
+    },
+    load(url, context, nextLoad) {
+      const id = sessionId(url);
+      if (!id) return nextLoad(url, context);
+      const session = sessions.get(id);
+      if (session) session.loaded = true;
+      const file = fileURLToPath(url);
+      if (!TYPESCRIPT_EXTENSION.test(file)) {
+        const loaded = nextLoad(url, context);
+        if (loaded.format === "commonjs") commonjsFiles.add(file);
+        return loaded;
+      }
+      const result = transformSync(file, readFileSync2(file, "utf8"));
+      if (result.errors.length > 0) {
+        throw new TranspileError(`Could not transpile ${file}.`, { cause: result.errors[0] });
+      }
+      return { format: "module", source: result.code, shortCircuit: true };
     }
   });
-  return changed ? output.toString() : code;
 }
-function isImportMetaUrl(node) {
-  if (node.computed || !isIdentifier(node.property, "url")) return false;
-  const object = node.object;
-  return isNode(object, "MetaProperty") && isIdentifier(object.meta, "import") && isIdentifier(object.property, "meta");
-}
-function isIdentifier(value, name) {
-  return isNode(value, "Identifier") && value.name === name;
-}
-function isNode(value, type) {
-  return !!value && typeof value === "object" && value.type === type;
+function isCommonJs(resolved) {
+  if (resolved.format) return resolved.format === "commonjs";
+  if (!resolved.url.startsWith("file:")) return false;
+  const file = fileURLToPath(resolved.url);
+  if (file.endsWith(".cjs")) return true;
+  return file.endsWith(".js") && nearestPackageType(dirname2(file)) !== "module";
+}
+function sessionId(url) {
+  if (!url?.startsWith("file:") || !url.includes(`${SESSION_PARAM}=`)) return void 0;
+  return new URL(url).searchParams.get(SESSION_PARAM) ?? void 0;
+}
+function withSession(url, id) {
+  return `${url}?${SESSION_PARAM}=${id}`;
+}
+function isRelative(specifier) {
+  return specifier.startsWith("./") || specifier.startsWith("../");
+}
+function linkedPackageFile(url) {
+  if (!url.startsWith("file:")) return void 0;
+  const file = fileURLToPath(url);
+  return file.includes(`${sep}node_modules${sep}`) ? void 0 : file;
+}
+function resolveRelative(specifier, parentURL) {
+  const base = fileURLToPath(new URL(specifier, parentURL));
+  const candidates = [
+    base,
+    ...RESOLVE_EXTENSIONS.map((extension) => base + extension),
+    ...extname(base) === ".js" ? [base.slice(0, -3) + ".ts"] : [],
+    ...RESOLVE_EXTENSIONS.map((extension) => join2(base, `index${extension}`))
+  ];
+  return candidates.find((candidate) => existsSync2(candidate) && statSync(candidate).isFile());
 }
 
 // src/bundle.ts
+var debug = debuglog("panda");
 var nodeBuiltins = /* @__PURE__ */ new Set([...builtinModules, ...builtinModules.map((mod) => `node:${mod}`)]);
 async function bundleConfig(filepath, cwd) {
+  const transpiled = await loadTranspiled(filepath, cwd);
+  if (transpiled) return transpiled;
   const { rolldown } = await import("rolldown");
   const build = await rolldown({
     input: filepath,
@@ -98,38 +253,77 @@ async function bundleConfig(filepath, cwd) {
   }
   const dependencies = collectDependencies(chunks.output, filepath, cwd);
   const mod = await loadBundledModule(filepath, output.code);
+  return { config: await configFromModule(mod), dependencies };
+}
+async function loadTranspiled(filepath, cwd) {
+  const file = localFile(filepath, cwd);
+  if (!file || !existsSync3(file) || !canTranspile(file)) return void 0;
+  try {
+    const { value, files } = await importTranspiled(file, configFromModule);
+    const base = canonical(cwd);
+    const dependencies = new Set(files.map((dependency) => normalize(relative(base, canonical(dependency)))));
+    return { config: value, dependencies: Array.from(dependencies) };
+  } catch (error) {
+    if (!isLoaderFailure(error)) throw error;
+    debug("loading %s with the bundler: %s", relative(cwd, file) || file, errorMessage(error));
+    return void 0;
+  }
+}
+function localFile(filepath, cwd) {
+  if (isAbsolute2(filepath)) return filepath;
+  if (filepath.startsWith(".")) return join3(cwd, filepath);
+  return void 0;
+}
+async function importInstalledConfig(specifier, cwd) {
+  if (specifier.startsWith(".") || isAbsolute2(specifier)) return void 0;
+  const resolved = tryResolveFrom(specifier, cwd);
+  if (!resolved) return void 0;
+  const file = canonical(resolved);
+  if (!file.includes(`${sep2}node_modules${sep2}`) || !isEsmFile(file)) return void 0;
+  const mod = await import(
+    /* @vite-ignore */
+    `${pathToFileURL3(file).href}?mtime=${statSync2(file).mtimeMs}`
+  );
+  return { config: await configFromModule(mod), dependencies: [normalize(relative(canonical(cwd), file))] };
+}
+async function configFromModule(mod) {
   const hasDefaultExport = Object.prototype.hasOwnProperty.call(mod ?? {}, "default");
   const exported = hasDefaultExport ? mod.default : mod;
-  const config = hasDefaultExport && isPromiseLike(exported) ? await exported : exported;
-  return { config, dependencies };
+  return hasDefaultExport && isPromiseLike(exported) ? await exported : exported;
+}
+function isEsmFile(file) {
+  const extension = extname2(file);
+  if (extension === ".mjs") return true;
+  if (extension !== ".js") return false;
+  return nearestPackageType(dirname3(file)) === "module";
 }
 async function loadBundledModule(filepath, code) {
   const target = tempTargetFor(filepath);
-  let evalError;
-  if (target) {
+  if (target && await writeTempModule(target, code)) {
     try {
-      await mkdir(dirname(target), { recursive: true });
-      await writeFile(target, code);
-      try {
-        return await import(
-          /* @vite-ignore */
-          pathToFileURL2(target).href
-        );
-      } finally {
-        void unlink(target).catch(() => void 0);
-      }
+      return await import(
+        /* @vite-ignore */
+        pathToFileURL3(target).href
+      );
     } catch (error) {
-      if (!isUnresolvedTempModule(error, target)) evalError = error;
+      if (!isUnresolvedTempModule(error, target)) throw error;
+    } finally {
+      void unlink(target).catch(() => void 0);
     }
   }
   const dataUrl = `data:text/javascript;base64,${Buffer.from(code).toString("base64")}`;
+  return await import(
+    /* @vite-ignore */
+    dataUrl
+  );
+}
+async function writeTempModule(target, code) {
   try {
-    return await import(
-      /* @vite-ignore */
-      dataUrl
-    );
-  } catch (error) {
-    throw evalError ?? error;
+    await mkdir(dirname3(target), { recursive: true });
+    await writeFile(target, code);
+    return true;
+  } catch {
+    return false;
   }
 }
 function isUnresolvedTempModule(error, target) {
@@ -139,16 +333,16 @@ function isUnresolvedTempModule(error, target) {
 function tempTargetFor(filepath) {
   const unique = `${Date.now().toString(36)}-${Math.random().toString(36).slice(2)}`;
   const name = `panda.config.bundled.${unique}.mjs`;
-  const nodeModules = nearestNodeModules(dirname(filepath));
-  const base = nodeModules ? join(nodeModules, ".panda") : join(tmpdir(), "panda-config");
-  return join(base, name);
+  const nodeModules = nearestNodeModules(dirname3(filepath));
+  const base = nodeModules ? join3(nodeModules, ".panda") : join3(tmpdir(), "panda-config");
+  return join3(base, name);
 }
 function nearestNodeModules(start) {
   let current = start;
   while (true) {
-    const candidate = join(current, "node_modules");
-    if (existsSync(candidate)) return candidate;
-    const parent = dirname(current);
+    const candidate = join3(current, "node_modules");
+    if (existsSync3(candidate)) return candidate;
+    const parent = dirname3(current);
     if (parent === current) return void 0;
     current = parent;
   }
@@ -179,7 +373,7 @@ function canonical(filepath) {
 
 // src/find.ts
 import { readdirSync } from "node:fs";
-import { dirname as dirname2, resolve } from "node:path";
+import { dirname as dirname4, resolve as resolve2 } from "node:path";
 var configFiles = /* @__PURE__ */ new Set([
   "panda.config.ts",
   "panda.config.js",
@@ -190,7 +384,7 @@ var configFiles = /* @__PURE__ */ new Set([
 ]);
 var isPandaConfig = (file) => configFiles.has(file);
 function findUp(cwd) {
-  let dir = resolve(cwd);
+  let dir = resolve2(cwd);
   while (true) {
     let entries;
     try {
@@ -199,8 +393,8 @@ function findUp(cwd) {
       entries = [];
     }
     const match = entries.find(isPandaConfig);
-    if (match) return resolve(dir, match);
-    const parent = dirname2(dir);
+    if (match) return resolve2(dir, match);
+    const parent = dirname4(dir);
     if (parent === dir) return void 0;
     dir = parent;
   }
@@ -208,7 +402,7 @@ function findUp(cwd) {
 function findConfig(options) {
   const { cwd, file } = options;
   if (file) {
-    return resolve(cwd, file);
+    return resolve2(cwd, file);
   }
   const configPath = findUp(cwd);
   if (!configPath) {
@@ -441,42 +635,13 @@ import { normalize as normalize2, relative as relative5 } from "node:path";
 import {
   outdirBasename
 } from "@pandacss/compiler-shared";
-import { readFileSync as readFileSync2, statSync } from "node:fs";
-import { dirname as dirname4, resolve as resolve4 } from "node:path";
-import { pathToFileURL as pathToFileURL3 } from "node:url";
-
-// src/resolve.ts
-import { createRequire } from "node:module";
-import { resolve as resolve2 } from "node:path";
-function tryResolveFrom(request, fromDir) {
-  try {
-    return createRequire(resolve2(fromDir, "noop.js")).resolve(request, { paths: [fromDir] });
-  } catch (error) {
-    if (isResolveMiss(error)) return void 0;
-    throw error;
-  }
-}
-function isResolveMiss(error) {
-  const code = errorCode(error);
-  return code === "MODULE_NOT_FOUND" || code === "ERR_PACKAGE_PATH_NOT_EXPORTED";
-}
-function resolveFrom(request, fromDir) {
-  try {
-    return { kind: "resolved", path: createRequire(resolve2(fromDir, "noop.js")).resolve(request, { paths: [fromDir] }) };
-  } catch (error) {
-    const code = errorCode(error);
-    if (code === "ERR_PACKAGE_PATH_NOT_EXPORTED") return { kind: "not-exported" };
-    if (code === "MODULE_NOT_FOUND") return { kind: "not-installed" };
-    throw error;
-  }
-}
-function errorCode(error) {
-  return typeof error === "object" && error !== null && "code" in error ? error.code : void 0;
-}
+import { readFileSync as readFileSync4, statSync as statSync3 } from "node:fs";
+import { dirname as dirname6, resolve as resolve4 } from "node:path";
+import { pathToFileURL as pathToFileURL4 } from "node:url";
 
 // src/design-system/package.ts
-import { existsSync as existsSync2, readFileSync } from "node:fs";
-import { dirname as dirname3, join as join2 } from "node:path";
+import { existsSync as existsSync4, readFileSync as readFileSync3 } from "node:fs";
+import { dirname as dirname5, join as join4 } from "node:path";
 
 // src/design-system/publishable-files.ts
 import { relative as relative3, resolve as resolve3 } from "node:path";
@@ -598,7 +763,7 @@ function readPackageIdentity(cwd) {
   if (packagePath === void 0) {
     throw new Error(`Could not find a package.json from ${JSON.stringify(cwd)} to build the design system manifest.`);
   }
-  const pkg = JSON.parse(readFileSync(packagePath, "utf8"));
+  const pkg = JSON.parse(readFileSync3(packagePath, "utf8"));
   const name = pkg.name;
   if (typeof name !== "string" || name.length === 0) {
     throw new Error(`${JSON.stringify(packagePath)} has no "name"; a design system must be a named package.`);
@@ -655,9 +820,9 @@ function isSubpathExportMap(exports) {
 function nearestPackageJson(start) {
   let current = start;
   while (true) {
-    const candidate = join2(current, "package.json");
-    if (existsSync2(candidate)) return candidate;
-    const parent = dirname3(current);
+    const candidate = join4(current, "package.json");
+    if (existsSync4(candidate)) return candidate;
+    const parent = dirname5(current);
     if (parent === current) return void 0;
     current = parent;
   }
@@ -692,7 +857,7 @@ async function loadDesignSystemChain(spec, cwd, deps) {
     levels.push(level);
     if (parent === void 0) break;
     declaredBy = level.info.name;
-    fromDir = dirname4(manifestPath);
+    fromDir = dirname6(manifestPath);
     currentSpec = parent;
   }
   return levels.reverse();
@@ -730,7 +895,7 @@ function collectArtifactConflicts(metadata) {
     patterns: ds.patternNames.filter((name) => appPatterns.has(name))
   })).filter((entry) => entry.recipes.length > 0 || entry.patterns.length > 0);
 }
-function collectExportMissingDiagnostics(metadata) {
+function collectExportMissingDiagnostics(metadata, jsxFramework) {
   const overlay = buildCodegenOverlay(metadata);
   if (!overlay) return [];
   const [ds] = metadata.designSystem;
@@ -745,9 +910,8 @@ function collectExportMissingDiagnostics(metadata) {
   if (overlay.ownedPatterns.length > 0) {
     required.push("./patterns", "./patterns/*");
   }
-  const appPatterns = metadata?.userPatternNames?.length ?? 0;
-  const dsPatterns = ds.patternNames?.length ?? 0;
-  if (overlay.ownedPatterns.length > 0 || overlay.virtualizeCss && (appPatterns > 0 || dsPatterns > 0)) {
+  const reexportsJsx = overlay.virtualizeCss || overlay.ownedPatterns.length > 0;
+  if (generatesJsx(jsxFramework) && reexportsJsx) {
     required.push("./jsx", "./jsx/*");
   }
   return required.filter((subpath) => !hasExport(ds.packageExports, subpath)).map((subpath) => exportMissingDiagnostic(ds.name, subpath));
@@ -795,6 +959,10 @@ function identCollisions(kind, names) {
   }
   return collisions;
 }
+var JSX_FRAMEWORKS = /* @__PURE__ */ new Set(["react", "preact", "solid", "vue"]);
+function generatesJsx(jsxFramework) {
+  return jsxFramework !== void 0 && JSX_FRAMEWORKS.has(jsxFramework);
+}
 function hasExport(packageExports, subpath) {
   return packageExports != null && Object.prototype.hasOwnProperty.call(packageExports, subpath);
 }
@@ -843,7 +1011,7 @@ function manifestNotExportedError(spec) {
 async function loadManifestLevel(spec, manifestPath, deps) {
   let parsed;
   try {
-    parsed = JSON.parse(readFileSync2(manifestPath, "utf8"));
+    parsed = JSON.parse(readFileSync4(manifestPath, "utf8"));
   } catch (error) {
     const message = `Failed to parse ${JSON.stringify(manifestPath)} as JSON: ${errorMessage(error)}. This file must be generated by \`panda lib\`, not hand-written or added to \`include\`.`;
     throw createConfigError(message, [
@@ -851,8 +1019,8 @@ async function loadManifestLevel(spec, manifestPath, deps) {
     ]);
   }
   const manifest = validateManifest(spec, manifestPath, parsed);
-  const presetPath = resolve4(dirname4(manifestPath), manifest.preset);
-  const buildInfoPath = resolve4(dirname4(manifestPath), manifest.buildInfo);
+  const presetPath = resolve4(dirname6(manifestPath), manifest.preset);
+  const buildInfoPath = resolve4(dirname6(manifestPath), manifest.buildInfo);
   deps.add(presetPath);
   deps.add(buildInfoPath);
   let preset;
@@ -892,9 +1060,9 @@ async function loadManifestLevel(spec, manifestPath, deps) {
 }
 function readPackageExports(manifestPath) {
   try {
-    const packageJsonPath = nearestPackageJson(dirname4(manifestPath));
+    const packageJsonPath = nearestPackageJson(dirname6(manifestPath));
     if (packageJsonPath === void 0) return void 0;
-    const pkg = JSON.parse(readFileSync2(packageJsonPath, "utf8"));
+    const pkg = JSON.parse(readFileSync4(packageJsonPath, "utf8"));
     return isExportsMap(pkg.exports) ? pkg.exports : void 0;
   } catch {
     return void 0;
@@ -904,8 +1072,8 @@ function isExportsMap(value) {
   return typeof value === "object" && value !== null && !Array.isArray(value);
 }
 function presetImportUrl(path) {
-  const url = pathToFileURL3(path);
-  url.searchParams.set("mtime", String(statSync(path).mtimeMs));
+  const url = pathToFileURL4(path);
+  url.searchParams.set("mtime", String(statSync3(path).mtimeMs));
   return url.href;
 }
 function designSystemImportMap(map, spec) {
@@ -1009,8 +1177,8 @@ function unsupportedSpecifierError(spec, protocol) {
 }
 
 // src/design-system/smart-include.ts
-import { existsSync as existsSync3 } from "node:fs";
-import { dirname as dirname5, isAbsolute as isAbsolute4, join as join3, relative as relative4, resolve as resolve5, sep } from "node:path";
+import { existsSync as existsSync5 } from "node:fs";
+import { dirname as dirname7, isAbsolute as isAbsolute4, join as join5, relative as relative4, resolve as resolve5, sep as sep3 } from "node:path";
 var SMART_INCLUDE_EXTENSIONS = ["js", "mjs", "cjs", "jsx", "ts", "cts", "mts", "tsx", "vue", "svelte", "astro"];
 var MANIFEST_SUBPATH = "panda/lib.json";
 var PACKAGE_SPECIFIER = /^(?:@[a-z0-9-~][a-z0-9-._~]*\/)?[a-z0-9-~][a-z0-9-._~]*$/i;
@@ -1037,11 +1205,11 @@ function resolveSmartInclude(include, cwd, deps) {
       next.push(entry);
       continue;
     }
-    if (existsSync3(join3(packageDir, ...MANIFEST_SUBPATH.split("/")))) {
+    if (existsSync5(join5(packageDir, ...MANIFEST_SUBPATH.split("/")))) {
       offenders.push(entry);
       continue;
     }
-    deps.add(join3(packageDir, "package.json"));
+    deps.add(join5(packageDir, "package.json"));
     const base = globBase(packageDir, cwd);
     next.push(`${base}/**/*.{${SMART_INCLUDE_EXTENSIONS.join(",")}}`);
     excludes.push(`${base}/**/node_modules/**`);
@@ -1060,11 +1228,11 @@ function mergeExcludes(existing, additions) {
   return [...existing ?? [], ...additions];
 }
 function isLocalPath(entry, cwd) {
-  return existsSync3(isAbsolute4(entry) ? entry : resolve5(cwd, entry));
+  return existsSync5(isAbsolute4(entry) ? entry : resolve5(cwd, entry));
 }
 function resolvePackageDir(spec, cwd) {
   const fromPackageJson = tryResolve(`${spec}/package.json`, cwd);
-  if (fromPackageJson !== void 0) return dirname5(fromPackageJson);
+  if (fromPackageJson !== void 0) return dirname7(fromPackageJson);
   const fromEntry = tryResolve(spec, cwd);
   return fromEntry === void 0 ? void 0 : nearestPackageDir(fromEntry);
 }
@@ -1079,13 +1247,13 @@ function tryResolve(request, cwd) {
 function isInsideCwd(relativePath) {
   if (relativePath === "" || relativePath === "..") return false;
   if (isAbsolute4(relativePath)) return false;
-  return !relativePath.startsWith(`..${sep}`);
+  return !relativePath.startsWith(`..${sep3}`);
 }
 function nearestPackageDir(from) {
-  let dir = dirname5(from);
+  let dir = dirname7(from);
   while (true) {
-    if (existsSync3(join3(dir, "package.json"))) return dir;
-    const parent = dirname5(dir);
+    if (existsSync5(join5(dir, "package.json"))) return dir;
+    const parent = dirname7(dir);
     if (parent === dir) return void 0;
     dir = parent;
   }
@@ -1309,7 +1477,7 @@ function collectPresetResolvedHooks(config) {
   return collectPluginHookHandlers(config, "preset:resolved");
 }
 async function runPresetResolvedHooks(preset, source, hooks) {
-  let current = preset;
+  let current = hooks.length > 0 ? clone(preset) : preset;
   const name = source.name ?? source.specifier ?? presetName(current) ?? "unknown-preset";
   for (const entry of hooks) {
     const hook = normalizeHook(entry.value, "preset:resolved");
@@ -1323,7 +1491,7 @@ async function runPresetResolvedHooks(preset, source, hooks) {
 async function resolvePreset(preset, cwd) {
   if (typeof preset === "string") {
     try {
-      const result = await bundleConfig(preset, cwd);
+      const result = await importInstalledConfig(preset, cwd) ?? await bundleConfig(preset, cwd);
       return {
         config: ensureConfigObject(result.config, preset),
         dependencies: result.dependencies,
@@ -1551,15 +1719,15 @@ function isConfigSnapshot(input) {
 }
 
 // src/version.ts
-import { readFileSync as readFileSync3 } from "node:fs";
-import { dirname as dirname6, join as join4 } from "node:path";
-import { fileURLToPath } from "node:url";
+import { readFileSync as readFileSync5 } from "node:fs";
+import { dirname as dirname8, join as join6 } from "node:path";
+import { fileURLToPath as fileURLToPath2 } from "node:url";
 var MAJOR_VERSION_RE = /\d+/;
 var STAMPABLE_PANDA_RANGE_RE = /^[v=><~^]|^\d/;
 function readPandaVersion() {
   try {
-    const pkgPath = join4(dirname6(fileURLToPath(import.meta.url)), "../package.json");
-    return JSON.parse(readFileSync3(pkgPath, "utf8")).version;
+    const pkgPath = join6(dirname8(fileURLToPath2(import.meta.url)), "../package.json");
+    return JSON.parse(readFileSync5(pkgPath, "utf8")).version;
   } catch {
     return void 0;
   }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@pandacss/config",
-  "version": "2.1.1",
+  "version": "2.1.2",
   "description": "Self-contained loader that bundles and serializes a Panda config for the Rust compiler",
   "type": "module",
   "main": "./dist/index.js",
@@ -39,8 +39,8 @@
     "dist"
   ],
   "dependencies": {
-    "@pandacss/compiler-shared": "2.1.1",
-    "@pandacss/types": "2.1.1",
+    "@pandacss/compiler-shared": "2.1.2",
+    "@pandacss/types": "2.1.2",
     "acorn": "^8.17.0",
     "acorn-walk": "^8.3.5",
     "javascript-stringify": "2.1.0",