@pandacss/compiler 2.0.0-beta.8 → 2.0.0-beta.9

package/dist/{chunk-QPHZ2RG2.js → chunk-G4RVGB4O.js}

@@ -91,8 +91,7 @@ var fallbackBuildInfo = new BuildInfo({
 var fallbackDesignSystem = new DesignSystem(
   {
     createManifest: (input) => ({ ...input, schemaVersion: -1 }),
-    manifestSchemaVersion: () => -1,
-    resolveChain: () => ({ status: "ordered", order: [] })
+    manifestSchemaVersion: () => -1
   },
   fallbackBuildInfo
 );
@@ -139,9 +138,6 @@ var FallbackCompiler = class _FallbackCompiler {
   designSystemManifestSchemaVersion() {
     return -1;
   }
-  resolveDesignSystemChain() {
-    return { status: "ordered", order: [] };
-  }
   config() {
     return {};
   }
@@ -218,6 +214,17 @@ var FallbackCompiler = class _FallbackCompiler {
   inspectFileSource(_path, _source) {
     return { usages: [], diagnostics: [], calls: [], jsx: [], tokenRefs: [], componentEntries: [], styleEntries: [] };
   }
+  transformSource(input) {
+    return {
+      code: input.source,
+      map: null,
+      changed: false,
+      bailed: false,
+      diagnostics: [],
+      dependencies: [],
+      helper: { needsCx: false, needsCva: false, needsSva: false }
+    };
+  }
   inspectFile(input) {
     return { ...this.inspectFileSource(input.path, input.source), path: input.path };
   }
@@ -230,6 +237,9 @@ var FallbackCompiler = class _FallbackCompiler {
   suggestTokens() {
     return [];
   }
+  suggestSemanticTokens() {
+    return [];
+  }
   writeArtifacts(_options) {
     return [];
   }
@@ -299,6 +309,9 @@ var fallback = {
   },
   flushTracing() {
   },
+  takeTimingsJson() {
+    return void 0;
+  },
   shutdownTracing() {
     return false;
   },
@@ -453,98 +466,215 @@ import {
   compilePreset,
   defaultImportMap,
   diffConfig,
-  loadConfig,
+  filterPublishableLibFiles,
+  loadConfig as loadConfig2,
   mergeExcludes,
   readPackageIdentity,
+  readPandaVersion as readPandaVersion2,
+  resolvePublishedPandaRange,
   resolveSmartInclude,
   syncExports,
   toPosixRelative,
   toRelativeKey
 } from "@pandacss/config";
 
+// src/tooling/create-project.ts
+import { defaultConfig } from "@pandacss/compiler-shared";
+import { loadConfig } from "@pandacss/config";
+
 // src/design-system.ts
 import "@pandacss/compiler-shared";
 import { readPandaVersion } from "@pandacss/config";
 function hydrateDesignSystem(compiler, chain, consumerTokenPaths = []) {
-  if (!chain || chain.length === 0) return [];
+  if (!chain || chain.length === 0) {
+    return [];
+  }
   const pandaVersion = readPandaVersion();
   const diagnostics = [];
-  for (const ds of chain) diagnostics.push(...hydrateLevel(compiler, ds, pandaVersion, consumerTokenPaths));
+  for (const ds of chain) {
+    diagnostics.push(...hydrateLevel(compiler, ds, pandaVersion, consumerTokenPaths));
+  }
   return diagnostics;
 }
 function hydrateLevel(compiler, ds, pandaVersion, consumerTokenPaths) {
   const compat = compiler.designSystem.validate(ds.manifest, { pandaVersion });
-  if (!compat.ok) throw incompatibleManifestError(compiler, ds, compat.reason, pandaVersion);
-  const diagnostics = [];
+  if (!compat.ok) {
+    throw incompatibleManifestError(compiler, ds, compat.reason, pandaVersion);
+  }
+  const diagnostics = hydrateArtifacts(compiler, ds, pandaVersion);
+  diagnostics.push(...tokenConflictDiagnostics(ds, consumerTokenPaths));
+  return diagnostics;
+}
+function hydrateArtifacts(compiler, ds, pandaVersion) {
+  if (ds.optionMismatch && ds.optionMismatch.length > 0) {
+    const diagnostic = recoverFromSources(
+      compiler,
+      ds,
+      (sourceCount, severity) => optionMismatchDiagnostic(ds, sourceCount, severity)
+    );
+    return [diagnostic];
+  }
   let buildInfo;
   try {
     const content = compiler.fs.readFile(ds.buildInfoPath);
-    if (content == null) throw new Error(`file not found`);
+    if (content == null) {
+      throw new Error("file not found");
+    }
     buildInfo = JSON.parse(content);
   } catch (error) {
-    if (!tryStaleFallback(compiler, ds, diagnostics)) throw hydrateReadError(ds, error);
-  }
-  if (buildInfo) {
-    const result = compiler.designSystem.load(ds.manifest, { buildInfo, pandaVersion });
-    if (!result.ok && !tryStaleFallback(compiler, ds, diagnostics)) throw hydrateLoadError(ds, result.reason);
+    const issue = { kind: "read", detail: errorMessage(error) };
+    const diagnostic = recoverFromSources(
+      compiler,
+      ds,
+      (sourceCount, severity) => buildInfoDiagnostic(ds, issue, sourceCount, severity)
+    );
+    return [diagnostic];
+  }
+  const result = compiler.designSystem.load(ds.manifest, { buildInfo, pandaVersion });
+  if (!result.ok) {
+    const issue = result.reason === "schemaVersion" ? {
+      kind: "schemaVersion",
+      received: buildInfo.schemaVersion,
+      expected: compiler.buildInfo.schemaVersion
+    } : { kind: "corrupt" };
+    const diagnostic = recoverFromSources(
+      compiler,
+      ds,
+      (sourceCount, severity) => buildInfoDiagnostic(ds, issue, sourceCount, severity)
+    );
+    return [diagnostic];
   }
-  diagnostics.push(...tokenConflictDiagnostics(ds, consumerTokenPaths));
-  return diagnostics;
+  return [];
 }
-function tryStaleFallback(compiler, ds, diagnostics) {
-  if (ds.files.length === 0) return false;
-  const sources = compiler.scan({ include: ds.files, cwd: compiler.path.dirname(ds.manifestPath) });
-  if (sources.length === 0) return false;
+function recoverFromSources(compiler, ds, createDiagnostic) {
+  const sources = extractFallbackSources(compiler, ds);
+  const severity = sources.length === 0 ? "error" : "warning";
+  const diagnostic = createDiagnostic(sources.length, severity);
+  if (sources.length === 0) {
+    throw diagnosticError(diagnostic);
+  }
   compiler.parseFiles(sources);
-  diagnostics.push({
+  return diagnostic;
+}
+function extractFallbackSources(compiler, ds) {
+  if (ds.files.length === 0) {
+    return [];
+  }
+  return compiler.scan({ include: ds.files, cwd: compiler.path.dirname(ds.manifestPath) });
+}
+function buildInfoDiagnostic(ds, issue, sourceCount, severity) {
+  const reason = buildInfoIssueMessage(issue);
+  const outcome = sourceCount > 0 ? ` Re-extracted ${sourceCount} source ${sourceCount === 1 ? "file" : "files"}.` : " No fallback source files were available.";
+  return {
     code: "design_system_buildinfo_stale",
-    severity: "warning",
+    severity,
     category: "designSystem",
-    message: `Re-extracting ${JSON.stringify(ds.name)} from source; rebuild it with \`panda lib\` to restore the fast path.`
-  });
-  return true;
+    file: ds.buildInfoPath,
+    message: `${JSON.stringify(ds.name)} build info ${reason}.${outcome}`,
+    help: [`Run \`panda lib\` in ${JSON.stringify(ds.name)} to rebuild panda.buildinfo.json.`]
+  };
+}
+function buildInfoIssueMessage(issue) {
+  if (issue.kind === "schemaVersion") {
+    return `uses schemaVersion ${formatValue(issue.received)}; expected ${issue.expected}`;
+  }
+  if (issue.kind === "read") {
+    return `could not be read: ${issue.detail}`;
+  }
+  return "is malformed or corrupt";
+}
+function optionMismatchDiagnostic(ds, sourceCount, severity) {
+  const options = ds.optionMismatch?.join(", ") ?? "class-name options";
+  const outcome = sourceCount > 0 ? ` Re-extracted ${sourceCount} source ${sourceCount === 1 ? "file" : "files"} with the consumer options.` : " No fallback source files were available, so the prebuilt class names cannot be used safely.";
+  return {
+    code: "design_system_option_mismatch",
+    severity,
+    category: "designSystem",
+    file: ds.manifestPath,
+    message: `${JSON.stringify(ds.name)} was built with different ${options}.${outcome}`,
+    help: [`Match ${options} with ${JSON.stringify(ds.name)}, or rebuild it with \`panda lib\`.`]
+  };
 }
 function tokenConflictDiagnostics(ds, consumerTokenPaths) {
-  if (consumerTokenPaths.length === 0 || ds.tokenPaths.length === 0) return [];
+  if (consumerTokenPaths.length === 0 || ds.tokenPaths.length === 0) {
+    return [];
+  }
   const designSystemTokenPaths = new Set(ds.tokenPaths);
   const conflicts = [...new Set(consumerTokenPaths.filter((path) => designSystemTokenPaths.has(path)))].sort();
-  return conflicts.map((path) => ({
-    code: "design_system_token_conflict",
-    severity: "warning",
-    category: "designSystem",
-    message: `Token ${JSON.stringify(path)} is defined by both ${JSON.stringify(ds.name)} and this config; the local value wins.`
-  }));
+  if (conflicts.length === 0) {
+    return [];
+  }
+  const preview = conflicts.slice(0, 3).map((path) => JSON.stringify(path)).join(", ");
+  const remainder = conflicts.length > 3 ? ` and ${conflicts.length - 3} more` : "";
+  return [
+    {
+      code: "design_system_token_conflict",
+      severity: "info",
+      category: "designSystem",
+      file: ds.manifestPath,
+      message: `${conflicts.length} token ${conflicts.length === 1 ? "path is" : "paths are"} defined by both ${JSON.stringify(ds.name)} and this config (${preview}${remainder}); the local values win.`
+    }
+  ];
 }
 function incompatibleManifestError(compiler, ds, reason, pandaVersion) {
   if (reason === "schemaVersion") {
-    return new Error(
-      `Failed to hydrate designSystem ${JSON.stringify(ds.name)} from ${JSON.stringify(ds.manifestPath)}: manifest schemaVersion ${ds.manifest.schemaVersion} is incompatible with this compiler (expected ${compiler.designSystem.schemaVersion}).`
-    );
+    return diagnosticError({
+      code: "design_system_version_mismatch",
+      severity: "error",
+      category: "designSystem",
+      file: ds.manifestPath,
+      message: `${JSON.stringify(ds.name)} panda.lib.json uses schemaVersion ${ds.manifest.schemaVersion}; expected ${compiler.designSystem.schemaVersion}.`,
+      help: [`Upgrade ${JSON.stringify(ds.name)}, or rebuild it with a compatible version of Panda.`]
+    });
   }
-  const running = pandaVersion ? ` (you are on ${pandaVersion})` : "";
-  return new Error(
-    `Failed to hydrate designSystem ${JSON.stringify(ds.name)}: manifest requires Panda ${ds.manifest.panda}${running}.`
-  );
+  const running = pandaVersion ? `; the consumer uses ${pandaVersion}` : "";
+  return diagnosticError({
+    code: "design_system_peer_range_unsatisfied",
+    severity: "error",
+    category: "designSystem",
+    file: ds.manifestPath,
+    message: `${JSON.stringify(ds.name)} requires Panda ${ds.manifest.panda}${running}.`,
+    help: [`Install a compatible Panda version or update ${JSON.stringify(ds.name)}.`]
+  });
 }
-function hydrateReadError(ds, error) {
-  return new Error(
-    `Failed to hydrate designSystem ${JSON.stringify(ds.name)} from ${JSON.stringify(ds.buildInfoPath)}: ${errorMessage(error)}`
-  );
+function diagnosticError(diagnostic) {
+  const error = new Error(diagnostic.message);
+  error.diagnostics = [diagnostic];
+  return error;
 }
-function hydrateLoadError(ds, reason) {
-  return new Error(
-    `Failed to hydrate designSystem ${JSON.stringify(ds.name)} from ${JSON.stringify(ds.buildInfoPath)}: incompatible buildInfo ${reason}.`
-  );
+function formatValue(value) {
+  return typeof value === "number" || typeof value === "string" ? JSON.stringify(value) : String(value);
 }
 function errorMessage(error) {
   return error instanceof Error ? error.message : String(error);
 }
 
+// src/tooling/create-project.ts
+function createProjectFromLoadedConfig(loaded) {
+  const compiler = createCompilerFromSnapshot({
+    config: loaded.config,
+    callbacks: loaded.callbacks,
+    hooks: loaded.hooks
+  });
+  const designSystemDiagnostics = hydrateDesignSystem(
+    compiler,
+    loaded.metadata?.designSystem,
+    loaded.metadata?.userTokenPaths ?? []
+  );
+  return {
+    compiler,
+    configPath: loaded.path,
+    dependencies: loaded.dependencies,
+    outdir: loaded.config.outdir ?? defaultConfig.outdir,
+    designSystemDiagnostics
+  };
+}
+
 // src/driver.ts
 var DEFAULT_DESIGN_SYSTEM_LIB_OUTDIR = "dist";
 var DEFAULT_DESIGN_SYSTEM_LIB_FILES = ["./**/*.{js,mjs}"];
 async function createNodeDriver(options) {
-  const loaded = await loadConfig({ cwd: options.cwd, file: options.configPath });
+  const loaded = await loadConfig2({ cwd: options.cwd, file: options.configPath });
   if (options.include?.length) applyIncludeOverride(loaded, options.cwd, options.include);
   return new NodeDriver(options, loaded);
 }
@@ -566,7 +696,7 @@ var NodeDriver = class extends BaseDriver {
   #designSystemArtifactSnapshot;
   #designSystemWatchTargets;
   constructor(options, loaded) {
-    const built = buildFromConfig(loaded);
+    const built = createProjectFromLoadedConfig(loaded);
     super(built.compiler);
     this.#options = options;
     this.#loaded = loaded;
@@ -638,14 +768,14 @@ var NodeDriver = class extends BaseDriver {
     return this.applyChanges(changes);
   }
   async reload() {
-    const next = await loadConfig({ cwd: this.#options.cwd, file: this.#options.configPath });
+    const next = await loadConfig2({ cwd: this.#options.cwd, file: this.#options.configPath });
     if (this.#options.include?.length) applyIncludeOverride(next, this.#options.cwd, this.#options.include);
     const diff = diffConfig(this.#loaded, next);
     const nextDesignSystemArtifactSnapshot = designSystemArtifactSnapshot(this.compiler, next);
     const designSystemArtifactsChanged = this.#designSystemArtifactSnapshot !== nextDesignSystemArtifactSnapshot;
     if (diff.hasChanged || designSystemArtifactsChanged) {
       this.#loaded = next;
-      const built = buildFromConfig(next);
+      const built = createProjectFromLoadedConfig(next);
       this.setCompiler(built.compiler);
       this.#designSystemDiagnostics = built.designSystemDiagnostics;
       this.#designSystemPreset = void 0;
@@ -702,6 +832,66 @@ var NodeDriver = class extends BaseDriver {
     }
     return files;
   }
+  cssgen(options) {
+    const output = super.cssgen(options);
+    this.runCssgenDone({
+      artifact: "styles.css",
+      content: output.css,
+      cwd: this.#options.cwd,
+      manifest: output.manifest,
+      layerRanges: output.layerRanges
+    });
+    return output;
+  }
+  writeCss(options) {
+    const result = super.writeCss(options);
+    this.runCssgenDone({
+      artifact: "styles.css",
+      content: result.css,
+      path: result.path,
+      outfile: options.outfile,
+      cwd: options.cwd ?? this.#options.cwd,
+      manifest: result.manifest,
+      layerRanges: result.layerRanges
+    });
+    return result;
+  }
+  writeLayerCss(options) {
+    const result = super.writeLayerCss(options);
+    this.runCssgenDone({
+      artifact: "styles.layer",
+      content: result.css,
+      path: result.path,
+      outfile: options.outfile,
+      cwd: options.cwd ?? this.#options.cwd,
+      manifest: result.manifest,
+      layerRanges: result.layerRanges
+    });
+    return result;
+  }
+  writeSplitCss(options) {
+    const result = super.writeSplitCss(options);
+    const cwd = options?.cwd ?? this.#options.cwd;
+    const outdir = result.root;
+    for (const file of result.files) {
+      const path = this.compiler.path.join([result.root, file.path]);
+      this.runCssgenDone({
+        artifact: "styles.split",
+        content: file.code,
+        path,
+        outdir,
+        cwd
+      });
+    }
+    return result;
+  }
+  runCssgenDone(args) {
+    const hooks = this.#loaded.hostHooks?.["cssgen:done"] ?? [];
+    for (const entry of hooks) {
+      const handler = resolveHookHandler(entry.value, "cssgen:done");
+      handler(args);
+    }
+  }
   codegenWithPrepareHooks(hooks, outdir, cwd, options) {
     let artifacts = this.compiler.generateArtifacts(toGenerateArtifactOptions(options));
     for (const entry of hooks) {
@@ -748,7 +938,7 @@ var NodeDriver = class extends BaseDriver {
   }
   writeDesignSystemLibArtifacts(options, preset, parsed) {
     const identity = readPackageIdentity(this.#options.cwd);
-    const pandaRange = options.panda ?? identity.pandaPeer ?? "*";
+    const pandaRange = resolvePublishedPandaRange(options.panda ?? identity.pandaPeer, readPandaVersion2());
     const outdir = options.outdir ?? DEFAULT_DESIGN_SYSTEM_LIB_OUTDIR;
     const outRoot = this.compiler.path.resolve(outdir);
     const manifestPath = this.compiler.path.join([outRoot, "panda.lib.json"]);
@@ -758,6 +948,16 @@ var NodeDriver = class extends BaseDriver {
     const buildInfo = this.compiler.buildInfo.normalize(info, {
       mapModuleKey: (key) => toRelativeKey(key, this.#options.cwd)
     });
+    const { files: libFiles, diagnostics: filesDiagnostics } = resolveDesignSystemLibFiles({
+      explicit: options.files,
+      compiler: this.compiler,
+      cwd: this.#options.cwd,
+      outRoot,
+      buildInfo,
+      packageRoot: this.compiler.path.dirname(identity.packagePath),
+      publishFiles: identity.publishFiles,
+      packageName: identity.name
+    });
     const manifest = this.compiler.designSystem.create({
       name: identity.name,
       version: identity.version,
@@ -766,7 +966,7 @@ var NodeDriver = class extends BaseDriver {
       buildInfo: "./panda.buildinfo.json",
       importMap: defaultImportMap(identity.name),
       designSystem: typeof this.config.designSystem === "string" ? this.config.designSystem : void 0,
-      files: options.files ?? inferDesignSystemLibFiles(this.compiler, this.#options.cwd, outRoot, buildInfo)
+      files: libFiles
     });
     this.compiler.writeArtifacts({
       outdir,
@@ -795,7 +995,7 @@ var NodeDriver = class extends BaseDriver {
         }
       ]
     });
-    const exportsChanged = syncPackageExports(this.compiler, identity.packagePath, {
+    const { changed: exportsChanged, conflicts } = syncPackageExports(this.compiler, identity.packagePath, {
       manifestPath,
       presetPath
     });
@@ -805,10 +1005,52 @@ var NodeDriver = class extends BaseDriver {
       presetPath,
       exportsChanged,
       parsedFileCount: parsed.parsedFileCount,
-      diagnostics: parsed.diagnostics
+      diagnostics: [...parsed.diagnostics, ...filesDiagnostics, ...exportConflictDiagnostics(identity.name, conflicts)]
     };
   }
 };
+function resolveDesignSystemLibFiles(options) {
+  if (options.explicit) {
+    return { files: options.explicit, diagnostics: [] };
+  }
+  const inferred = inferDesignSystemLibFiles(options.compiler, options.cwd, options.outRoot, options.buildInfo);
+  const { files, unpublished } = filterPublishableLibFiles({
+    files: inferred,
+    packageRoot: options.packageRoot,
+    outRoot: options.outRoot,
+    publishFiles: options.publishFiles
+  });
+  if (unpublished.length === 0) {
+    return { files, diagnostics: [] };
+  }
+  return {
+    files,
+    diagnostics: [unpublishedLibFilesDiagnostic(options.packageName, unpublished)]
+  };
+}
+function unpublishedLibFilesDiagnostic(name, unpublished) {
+  const sample = unpublished.slice(0, 3).map((path) => JSON.stringify(path)).join(", ");
+  const more = unpublished.length > 3 ? `, and ${unpublished.length - 3} more` : "";
+  return {
+    code: "design_system_files_not_publishable",
+    severity: "warning",
+    category: "designSystem",
+    message: `\`panda lib\` omitted ${unpublished.length === 1 ? "a fallback file" : "fallback files"} from ${JSON.stringify(name)}'s manifest because package.json \`"files"\` would not publish ${sample}${more}. Happy-path consumers still hydrate build info. For dist-only recovery, re-run with \`panda lib --files './**/*.{js,mjs}'\` (or the globs you actually publish).`
+  };
+}
+function exportConflictDiagnostics(name, conflicts) {
+  if (conflicts.length === 0) return [];
+  const paths = conflicts.map((path) => JSON.stringify(path)).join(", ");
+  const plural = conflicts.length > 1;
+  return [
+    {
+      code: "design_system_export_overwritten",
+      severity: "warning",
+      category: "designSystem",
+      message: `\`panda lib\` overwrote the existing ${paths} export${plural ? "s" : ""} in ${JSON.stringify(name)}'s package.json. Restore or rename ${plural ? "them" : "it"} if you still need the previous target${plural ? "s" : ""}.`
+    }
+  ];
+}
 function resolveHookHandler(value, name) {
   if (typeof value === "function") return value;
   if (!value || typeof value !== "object" || Array.isArray(value)) {
@@ -852,25 +1094,12 @@ function syncPackageExports(compiler, packagePath, paths) {
       ]
     });
   }
-  return result.changed;
+  return { changed: result.changed, conflicts: result.conflicts };
 }
 function stabilizePath(cwd, file) {
   const relativePath = toRelativeKey(file, cwd);
   return relativePath && !relativePath.startsWith("..") ? relativePath : file;
 }
-function buildFromConfig(loaded) {
-  const compiler = createCompilerFromSnapshot({
-    config: loaded.config,
-    callbacks: loaded.callbacks,
-    hooks: loaded.hooks
-  });
-  const designSystemDiagnostics = hydrateDesignSystem(
-    compiler,
-    loaded.metadata?.designSystem,
-    loaded.metadata?.userTokenPaths ?? []
-  );
-  return { compiler, designSystemDiagnostics };
-}
 function designSystemArtifactSnapshot(compiler, loaded) {
   return JSON.stringify(
     loaded.metadata?.designSystem?.map((ds) => ({
@@ -911,6 +1140,9 @@ function startTracing(options) {
 function flushTracing() {
   binding.flushTracing?.();
 }
+function takeTimingsJson() {
+  return binding.takeTimingsJson?.() ?? void 0;
+}
 function shutdownTracing() {
   return binding.shutdownTracing?.() ?? false;
 }
@@ -1010,8 +1242,7 @@ function attachInspection(compiler) {
 function toDesignSystemBinding(compiler) {
   return {
     createManifest: (input) => compiler.createDesignSystemManifest(input),
-    manifestSchemaVersion: () => compiler.designSystemManifestSchemaVersion(),
-    resolveChain: (manifests) => compiler.resolveDesignSystemChain(manifests)
+    manifestSchemaVersion: () => compiler.designSystemManifestSchemaVersion()
   };
 }
 function toNativeOptions(options) {
@@ -1035,6 +1266,7 @@ export {
   compile,
   startTracing,
   flushTracing,
+  takeTimingsJson,
   shutdownTracing,
   createCompiler,
   createCompilerFromSnapshot,