@csszyx/unplugin 0.16.0 → 0.17.1

package/dist/next-watcher.d.mts

@@ -1,5 +1,6 @@
-import { N as NextStateContext } from './shared/unplugin.BGog1Bib.mjs';
-import { a as NextWatcherCycleOptions, N as NextWatcherCycleResult } from './shared/unplugin.COlI0dJs.mjs';
+import { N as NextStateContext } from './shared/unplugin.XdPo6azz.mjs';
+export { c as NEXT_WATCH_LOCK_COMMAND } from './shared/unplugin.XdPo6azz.mjs';
+import { a as NextWatcherCycleOptions, N as NextWatcherCycleResult } from './shared/unplugin.CfXjAV63.mjs';
 
 /**
  *
@@ -11,6 +12,8 @@ type NextWatcherLoopCycleRunner = (context: NextStateContext, options: NextWatch
 interface NextWatcherLoopTimerHooks {
     setTimeout?: (callback: () => void, delayMs: number) => WatcherTimer;
     clearTimeout?: (timer: WatcherTimer) => void;
+    /** Clock that times a wait on the loader's lock; `Date.now` by default. */
+    now?: () => number;
 }
 
 /** Filesystem events that can change the materialized safelist. */
@@ -22,6 +25,8 @@ interface NextSafelistWatcherOptions extends NextWatcherLoopTimerHooks {
     debounceMs?: number;
     runCycle?: NextWatcherLoopCycleRunner;
     onError?: (error: unknown) => void;
+    /** Receives a notice the watcher keeps running through; dropped by default. */
+    onWarn?: (message: string) => void;
 }
 /**
  * Validate one watcher event path against the flat safelist shard directory.
@@ -75,8 +80,16 @@ declare class NextSafelistWatcher {
     get lastError(): unknown;
     /**
      * Materialize existing shards before accepting live filesystem events.
+     *
+     * `next watch` and `next dev` start together in the documented setup, so
+     * the Turbopack loader's first compile can hold the state lock at this
+     * exact moment. The initial cycle is then queued behind it instead of
+     * throwing, the same way a scheduled cycle waits.
+     *
+     * @returns The initial cycle's result, or `undefined` while it is queued
+     *   behind the Turbopack loader.
      */
-    start(): NextWatcherCycleResult;
+    start(): NextWatcherCycleResult | undefined;
     /**
      * Queue a materialization cycle for one relevant shard filesystem event.
      *

package/dist/next-watcher.mjs

@@ -1,11 +1,19 @@
 import * as path from 'node:path';
-import { r as runNextWatcherCycle } from './shared/unplugin.BLptVbUe.mjs';
+import { r as runNextWatcherCycle, b as NextSafelistStateLockedError, a as NEXT_TURBO_LOADER_LOCK_COMMAND } from './shared/unplugin.eCo7_znv.mjs';
+export { d as NEXT_WATCH_LOCK_COMMAND } from './shared/unplugin.eCo7_znv.mjs';
 import 'node:fs';
-import './shared/unplugin.DH_ij6cf.mjs';
+import './shared/unplugin.Ba3O1r8M.mjs';
 import 'node:crypto';
+import './shared/unplugin.wMeicb6E.mjs';
 import 'node:os';
 import 'proper-lockfile';
 
+const LOADER_LOCK_RETRY_MIN_MS = 50;
+const LOADER_LOCK_WARN_AFTER_MS = 1e3;
+const LOADER_LOCK_GIVE_UP_AFTER_MS = 6e4;
+function isHeldByTurbopackLoader(error) {
+  return error instanceof NextSafelistStateLockedError && error.holder.command === NEXT_TURBO_LOADER_LOCK_COMMAND;
+}
 class NextWatcherLoop {
   context;
   cycleOptions;
@@ -13,10 +21,15 @@ class NextWatcherLoop {
   runCycle;
   setTimeoutFn;
   clearTimeoutFn;
+  nowFn;
   onError;
+  onWarn;
   timer;
   disposed = false;
   pendingReasons = /* @__PURE__ */ new Set();
+  /** When the current wait on the loader's lock began; unset while not waiting. */
+  loaderWaitStartedAt;
+  loaderWaitWarned = false;
   lastResult;
   lastError;
   /**
@@ -30,7 +43,9 @@ class NextWatcherLoop {
     this.runCycle = options.runCycle ?? runNextWatcherCycle;
     this.setTimeoutFn = options.setTimeout ?? setTimeout;
     this.clearTimeoutFn = options.clearTimeout ?? clearTimeout;
+    this.nowFn = options.now ?? Date.now;
     this.onError = options.onError;
+    this.onWarn = options.onWarn;
   }
   /**
    *
@@ -53,17 +68,7 @@ class NextWatcherLoop {
       return;
     }
     this.pendingReasons.add(reason);
-    if (this.timer !== void 0) {
-      return;
-    }
-    this.timer = this.setTimeoutFn(() => {
-      try {
-        this.runPendingCycle();
-      } catch (error) {
-        this.lastError = error;
-        this.onError?.(error);
-      }
-    }, this.debounceMs);
+    this.schedule(this.debounceMs);
   }
   /**
    *
@@ -74,6 +79,32 @@ class NextWatcherLoop {
     }
     return this.runPendingCycle();
   }
+  /**
+   * Run the pending cycle now, or queue it when the Turbopack loader holds the
+   * lock.
+   *
+   * `flush` throws on every failure, which is what closing needs. Starting
+   * needs this instead: `next watch` and `next dev` start together, so the
+   * loader's first compile can hold the lock exactly when the initial cycle
+   * runs, and that overlap is not a failure.
+   *
+   * @returns The cycle result, or `undefined` when nothing was pending or the
+   *   cycle is queued behind the loader.
+   */
+  flushOrQueue() {
+    if (this.disposed || this.timer === void 0) {
+      return void 0;
+    }
+    const reasons = [...this.pendingReasons];
+    try {
+      return this.runPendingCycle();
+    } catch (error) {
+      if (this.waitForLoader(error, reasons)) {
+        return void 0;
+      }
+      throw error;
+    }
+  }
   /**
    *
    */
@@ -85,6 +116,75 @@ class NextWatcherLoop {
     this.pendingReasons.clear();
     this.disposed = true;
   }
+  /**
+   * Run the pending cycle after `delayMs`, unless a run is already scheduled.
+   *
+   * @param delayMs - How long to wait before running it.
+   */
+  schedule(delayMs) {
+    if (this.timer !== void 0) {
+      return;
+    }
+    this.timer = this.setTimeoutFn(() => {
+      const reasons = [...this.pendingReasons];
+      try {
+        this.runPendingCycle();
+      } catch (error) {
+        if (this.waitForLoader(error, reasons)) {
+          return;
+        }
+        this.lastError = error;
+        this.onError?.(error);
+      }
+    }, delayMs);
+  }
+  /**
+   * Queue a cycle again when it failed only because the Turbopack loader holds
+   * the lock.
+   *
+   * Retried, not dropped: the loader's pass read the shards as they stood when
+   * it began, and the event that woke this cycle may be newer. The wait is
+   * timed from the first refusal, says so once when it runs long, and ends in
+   * a reported failure when it runs longer than any live loader could explain.
+   *
+   * @param error - What the cycle threw.
+   * @param reasons - The reasons the failed cycle carried, queued again with it.
+   * @returns True when nothing should be reported: the cycle is queued, or the
+   *   loop was disposed meanwhile.
+   */
+  waitForLoader(error, reasons) {
+    if (!isHeldByTurbopackLoader(error)) {
+      return false;
+    }
+    const now = this.nowFn();
+    this.loaderWaitStartedAt ??= now;
+    const waited = now - this.loaderWaitStartedAt;
+    if (waited > LOADER_LOCK_GIVE_UP_AFTER_MS) {
+      this.endLoaderWait();
+      return false;
+    }
+    if (waited >= LOADER_LOCK_WARN_AFTER_MS && !this.loaderWaitWarned) {
+      this.loaderWaitWarned = true;
+      const warn = this.onWarn ?? (() => {
+      });
+      warn(
+        `[csszyx] next watch is waiting for the safelist lock held by the Turbopack loader (process ${error.holder.pid}). Classes added meanwhile get no CSS until it is released; a lock left by a loader that exited is recovered within 30 s.`
+      );
+    }
+    if (this.disposed) {
+      return true;
+    }
+    for (const reason of reasons) {
+      this.pendingReasons.add(reason);
+    }
+    this.schedule(Math.max(this.debounceMs, LOADER_LOCK_RETRY_MIN_MS));
+    return true;
+  }
+  /** Forget the current wait on the loader, once a cycle gets through or gives up. */
+  endLoaderWait() {
+    this.loaderWaitStartedAt = void 0;
+    this.loaderWaitWarned = false;
+  }
   /**
    *
    */
@@ -99,6 +199,7 @@ class NextWatcherLoop {
     const result = this.runCycle(this.context, this.cycleOptions, reasons);
     this.lastResult = result;
     this.lastError = void 0;
+    this.endLoaderWait();
     return result;
   }
 }
@@ -152,6 +253,14 @@ class NextSafelistWatcher {
   }
   /**
    * Materialize existing shards before accepting live filesystem events.
+   *
+   * `next watch` and `next dev` start together in the documented setup, so
+   * the Turbopack loader's first compile can hold the state lock at this
+   * exact moment. The initial cycle is then queued behind it instead of
+   * throwing, the same way a scheduled cycle waits.
+   *
+   * @returns The initial cycle's result, or `undefined` while it is queued
+   *   behind the Turbopack loader.
    */
   start() {
     if (this.closed) {
@@ -162,8 +271,8 @@ class NextSafelistWatcher {
     }
     this.started = true;
     this.loop.notify("initial");
-    const result = this.loop.flush();
-    if (!result) {
+    const result = this.loop.flushOrQueue();
+    if (!result && !this.loop.pending) {
       throw new Error("[csszyx] Next safelist watcher failed to run its initial cycle.");
     }
     return result;

package/dist/shared/{unplugin.C-oQU1jl.mjs → unplugin.2uf-U76p.mjs}

@@ -1,6 +1,6 @@
 import * as path from 'node:path';
 import { extractCrossModuleRegistryEntries, extractCrossModuleForwards } from '@csszyx/compiler';
-import { n as normalizePathSeparators } from './unplugin.DH_ij6cf.mjs';
+import { n as normalizePathSeparators } from './unplugin.wMeicb6E.mjs';
 import * as fs from 'node:fs';
 import { existsSync, statSync } from 'node:fs';
 import { createHash, randomUUID } from 'node:crypto';

package/dist/shared/{unplugin.BWnmKv07.cjs → unplugin.BKID6KXV.cjs}

@@ -2,7 +2,7 @@
 
 const path = require('node:path');
 const fs = require('node:fs');
-const safelistSource = require('./unplugin.DDSWQJYX.cjs');
+const safelistSource = require('./unplugin.DS6CFjim.cjs');
 const node_crypto = require('node:crypto');
 const node_os = require('node:os');
 const lockfile = require('proper-lockfile');
@@ -326,6 +326,8 @@ class NextSafelistStateLockedError extends Error {
   }
 }
 const NEXT_WATCH_LOCK_COMMAND = "csszyx next watch";
+const NEXT_TURBO_LOADER_LOCK_COMMAND = "csszyx next turbo-loader";
+const NEXT_PREBUILD_LOCK_COMMAND = "csszyx next prebuild";
 function formatLiveLockError(metadata) {
   return [
     `csszyx Next safelist state is already locked by process ${metadata.pid}.`,
@@ -593,6 +595,8 @@ function runNextWatcherCycle(context, options = {}) {
   }
 }
 
+exports.NEXT_PREBUILD_LOCK_COMMAND = NEXT_PREBUILD_LOCK_COMMAND;
+exports.NEXT_TURBO_LOADER_LOCK_COMMAND = NEXT_TURBO_LOADER_LOCK_COMMAND;
 exports.NEXT_WATCH_LOCK_COMMAND = NEXT_WATCH_LOCK_COMMAND;
 exports.NextSafelistStateLockedError = NextSafelistStateLockedError;
 exports.createNextStateContext = createNextStateContext;

package/dist/shared/{unplugin.PKo7wFzu.d.cts → unplugin.BO2_hyS3.d.cts}

@@ -523,6 +523,14 @@ interface PluginState {
      * by a raw selector consumer.
      */
     ownedClasses: Set<string>;
+    /**
+     * Owned classes that a mangle map WOULD carry: `ownedClasses` minus the
+     * authored ones and minus `manglePreserve`. Recorded whether or not
+     * mangling runs, because the bundle manifest lists them either way and used
+     * to read them off the map's keys — which is why the map had to be
+     * allocated on a build that never mangles.
+     */
+    mangleEligible: string[];
     /**
      * Classes written through author-facing class/className attributes. Any
      * overlap with ownedClasses must keep its original name because bundled
@@ -751,9 +759,18 @@ declare function unscopedMonorepoMessage(): string;
 /**
  * Whether a diagnostic is an advisory one — the class a build may hold back.
  *
- * Spread warnings, budget bails and `missing-css` fallbacks all describe absent
- * output and print regardless. What is left says the runtime path was taken
- * where a compiled one was possible: real, worth acting on, and not a failure.
+ * Advisory means one thing: the styles are THERE, and the note is about how
+ * they got there. An `sz`-site nudge fallback took the runtime path where a
+ * compiled one was possible; the precedence advisory says which of two sources
+ * won. Everything else describes output that is absent or dead, and a
+ * production build has to print it.
+ *
+ * Asked positively on purpose. The predicate used to be "not one of three known
+ * kinds", which quietly made every key and value diagnostic advisory: a
+ * production build of a file with five typo'd keys printed nothing but a census
+ * calling them fallbacks, while `csszyx check` on the same tree named all six.
+ * A classifier written by exclusion cannot stay right as diagnostics are added,
+ * because a new one joins the silent side by default.
  *
  * @param message - One raw diagnostic line as an engine emitted it.
  * @returns True when the diagnostic is advisory rather than a build result.
@@ -772,7 +789,7 @@ declare function isAdvisoryDiagnostic(message: string): boolean;
  * Suppression is the right default; implying zero is not. One line costs
  * nothing and keeps the difference visible.
  *
- * @param count - Advisory fallbacks the build declined to list.
+ * @param count - Advisory notes the build declined to list.
  * @returns The disclosure, or null when nothing was held back.
  */
 declare function suppressedAdvisoryMessage(count: number): string | null;
@@ -807,6 +824,22 @@ declare function resolveQuietMode(quiet: boolean | 'nudges' | QuietMode | undefi
  * @returns true when the warning should be printed.
  */
 declare function shouldEmitWarning(quiet: QuietMode, devOnly: boolean, isProduction: boolean): boolean;
+/**
+ * Emit one key or value diagnostic — the family that says a class is dead.
+ *
+ * Its own channel because the two that existed both answer a different
+ * question: `emitMissingCssFallback` handles fallback sites, and the advisory
+ * channel handles notes about styles that ARE present. A typo'd key matched
+ * neither, so a production build dropped it on the floor while `csszyx check`
+ * on the same tree exited 1 and named it. Muted only by `quiet: true`, on the
+ * same reasoning as the missing-css channel: wrong output is not a usage nudge.
+ *
+ * @param quiet - Resolved quiet mode.
+ * @param message - Compiler diagnostic to classify and emit.
+ * @param id - Bundler module identifier included in the warning.
+ * @param emit - Warning output channel.
+ */
+declare function emitKeyValueDiagnostic(quiet: QuietMode, message: string, id: string, emit: (message: string) => void): void;
 /**
  * Whether a transform diagnostic describes missing CSS and may be printed.
  *
@@ -1079,5 +1112,5 @@ declare const rollupPlugin: (options?: PartialCsszyxConfig) => InputPluginOption
  */
 declare const esbuildPlugin: (options?: PartialCsszyxConfig) => Plugin;
 
-export { isRSCServerModule as $, unplugin as A, deleteRSCModuleRecord as B, emitMissingCssFallback as D, esbuildPlugin as E, extractGlobalVarAliasesForManifest as F, fileMayContainSafelistableSz as H, findLocalImportSources as I, findRSCBoundaryViolation as J, findRSCGraphViolation as K, hasInjectableTailwindCandidate as L, hasTokens as N, hasUseClientDirective as O, hasUseServerDirective as T, isAdvisoryDiagnostic as U, isCompileSourceOptedIn as W, isHardIgnoredPath as X, isMangleableCssId as Y, isMonorepoPackage as Z, isPackagesSkippedSource as _, lateMangleCensusMessage as a0, mangleCodeClassesSync as a1, mangleEligibleClasses as a2, mangleHybridHazardMessage as a3, mergeThemes as a4, missingTailwindEntryMessage as a5, normalizeGlobalVarAliasesForCache as a6, parseThemeBlocks as a7, parseUtilityBlocks as a8, realContentHashDisabledMessage as a9, recordGlobalVarSourceFile as aa, resolveCompileSourceDirs as ab, resolveNativeCacheIdentity as ac, resolveQuietMode as ad, rollupPlugin as ae, scanCustomPropertyNames as af, shouldEmitMissingCssFallback as ag, shouldEmitWarning as ah, shouldHoldAdvisories as ai, shouldTrackGlobalVarSources as aj, shouldWarnMissingTailwindEntry as ak, shouldWarnUnscopedMonorepo as al, skippedSzFilesMessage as am, suppressedAdvisoryMessage as an, unscopedMonorepoMessage as ao, vitePlugin as ap, watchModeMangleMessage as aq, webpackPlugin as ar, allocateMangleTokens as t, assertNoRSCBoundaryViolation as u, assertNoRSCGraphViolation as v, collectMangleHybridHazards as w, createGlobalVarMapAssetSource as x, createRSCModuleRecord as y, cssHasContentScope as z };
+export { isPackagesSkippedSource as $, unplugin as A, deleteRSCModuleRecord as B, emitKeyValueDiagnostic as D, emitMissingCssFallback as E, esbuildPlugin as F, extractGlobalVarAliasesForManifest as H, fileMayContainSafelistableSz as I, findLocalImportSources as J, findRSCBoundaryViolation as K, findRSCGraphViolation as L, hasInjectableTailwindCandidate as N, hasTokens as O, hasUseClientDirective as T, hasUseServerDirective as U, isAdvisoryDiagnostic as W, isCompileSourceOptedIn as X, isHardIgnoredPath as Y, isMangleableCssId as Z, isMonorepoPackage as _, isRSCServerModule as a0, lateMangleCensusMessage as a1, mangleCodeClassesSync as a2, mangleEligibleClasses as a3, mangleHybridHazardMessage as a4, mergeThemes as a5, missingTailwindEntryMessage as a6, normalizeGlobalVarAliasesForCache as a7, parseThemeBlocks as a8, parseUtilityBlocks as a9, realContentHashDisabledMessage as aa, recordGlobalVarSourceFile as ab, resolveCompileSourceDirs as ac, resolveNativeCacheIdentity as ad, resolveQuietMode as ae, rollupPlugin as af, scanCustomPropertyNames as ag, shouldEmitMissingCssFallback as ah, shouldEmitWarning as ai, shouldHoldAdvisories as aj, shouldTrackGlobalVarSources as ak, shouldWarnMissingTailwindEntry as al, shouldWarnUnscopedMonorepo as am, skippedSzFilesMessage as an, suppressedAdvisoryMessage as ao, unscopedMonorepoMessage as ap, vitePlugin as aq, watchModeMangleMessage as ar, webpackPlugin as as, allocateMangleTokens as t, assertNoRSCBoundaryViolation as u, assertNoRSCGraphViolation as v, collectMangleHybridHazards as w, createGlobalVarMapAssetSource as x, createRSCModuleRecord as y, cssHasContentScope as z };
 export type { CssVarScanResult as C, GlobalVarScanCacheKeyInput as G, MangleHybridHazards as M, PlanGlobalVarAliasesInput as P, QuietMode as Q, RewriteGlobalVarCssAliasesOptions as R, ScanGlobalVarCssOptions as S, ValidateGlobalVarAliasInputsOptions as V, GlobalVarAliasPlan as a, GlobalVarCssAliasRewriteResult as b, CreateGlobalVarAliasValidationOptionsInput as c, GlobalVarAliasValidationResult as d, CssVarDefinition as e, CssVarLocation as f, CssVarReference as g, GlobalVarAliasDiagnostic as h, GlobalVarAliasDiagnosticSeverity as i, GlobalVarAliasEntry as j, GlobalVarCodeSource as k, GlobalVarCssAssetSource as l, GlobalVarCssSource as m, GlobalVarScanCacheEntry as n, MangleSelectorHazard as o, ParsedTheme as p, ParsedUtilities as q, RSCBoundaryViolation as r, RSCModuleRecord as s };

package/dist/shared/{unplugin.DH_ij6cf.mjs → unplugin.Ba3O1r8M.mjs}

@@ -1,6 +1,7 @@
 import { randomUUID } from 'node:crypto';
 import * as fs from 'node:fs';
 import * as path from 'node:path';
+import { n as normalizePathSeparators } from './unplugin.wMeicb6E.mjs';
 
 function sortStrings(values) {
   return [...values].sort((a, b) => {
@@ -10,11 +11,6 @@ function sortStrings(values) {
   });
 }
 
-const WINDOWS_PATH_SEPARATOR = String.fromCodePoint(92);
-function normalizePathSeparators(value) {
-  return value.split(WINDOWS_PATH_SEPARATOR).join("/");
-}
-
 const DEFAULT_RENAME_RETRIES = 5;
 const DEFAULT_RENAME_RETRY_DELAY_MS = 10;
 function isRetryableRenameError(error) {
@@ -255,4 +251,4 @@ function cssImportsTailwind(code) {
   return TAILWIND_IMPORT.test(stripCssBlockComments(code));
 }
 
-export { SAFELIST_FILE as S, appendTailwindSourceDirective as a, cssImportsTailwind as b, computeSafelistRelPath as c, atomicWriteFileSync as d, removeLegacySafelists as e, findPostcssConfigWithoutCsszyx as f, assertNoLegacySourceStylesheet as g, stripCssBlockComments as h, findLegacySourceDirective as i, legacySourceMessage as l, missingPostcssPluginMessage as m, normalizePathSeparators as n, renderSafelistFile as r, sortStrings as s };
+export { SAFELIST_FILE as S, appendTailwindSourceDirective as a, cssImportsTailwind as b, computeSafelistRelPath as c, atomicWriteFileSync as d, removeLegacySafelists as e, findPostcssConfigWithoutCsszyx as f, assertNoLegacySourceStylesheet as g, stripCssBlockComments as h, findLegacySourceDirective as i, legacySourceMessage as l, missingPostcssPluginMessage as m, renderSafelistFile as r, sortStrings as s };

package/dist/shared/unplugin.BqKLlo1h.cjs

@@ -0,0 +1,8 @@
+'use strict';
+
+const WINDOWS_PATH_SEPARATOR = String.fromCodePoint(92);
+function normalizePathSeparators(value) {
+  return value.split(WINDOWS_PATH_SEPARATOR).join("/");
+}
+
+exports.normalizePathSeparators = normalizePathSeparators;

package/dist/shared/{unplugin.Vn9x8SBP.mjs → unplugin.C3bgc29e.mjs}

@@ -2,9 +2,10 @@ import { readFileSync } from 'node:fs';
 import * as path from 'node:path';
 import { extractCrossModuleForwards, extractCrossModuleRegistryEntries, ensureRustTransformAvailable, transformRust, transformWasm, transform } from '@csszyx/compiler';
 import { DEFAULT_IMPORTED_STATIC_SZ } from '@csszyx/types';
-import { c as collectSpecifierAliases, i as importedSpecifiersIn, s as specifierBases, a as resolveProviderPathWith, b as recordResolvedEntry, f as forwardVisitKey, M as MAX_FORWARD_HOPS, d as isReadableProviderFile, e as createTransformCacheKey, g as readTransformCache, w as writeTransformCache } from './unplugin.C-oQU1jl.mjs';
-import { n as normalizePathSeparators, s as sortStrings } from './unplugin.DH_ij6cf.mjs';
+import { c as collectSpecifierAliases, i as importedSpecifiersIn, s as specifierBases, a as resolveProviderPathWith, b as recordResolvedEntry, f as forwardVisitKey, M as MAX_FORWARD_HOPS, d as isReadableProviderFile, e as createTransformCacheKey, g as readTransformCache, w as writeTransformCache } from './unplugin.2uf-U76p.mjs';
+import { n as normalizePathSeparators } from './unplugin.wMeicb6E.mjs';
 import { createHash } from 'node:crypto';
+import { s as sortStrings } from './unplugin.Ba3O1r8M.mjs';
 
 function resolveImportedStaticSz(value) {
   return value ?? DEFAULT_IMPORTED_STATIC_SZ;

package/dist/shared/{unplugin.Ceq-N4jI.mjs → unplugin.CK-DfKTP.mjs}

@@ -1,6 +1,6 @@
 import fs__default from 'node:fs';
 import path__default from 'node:path';
-import { s as sortStrings } from './unplugin.DH_ij6cf.mjs';
+import { s as sortStrings } from './unplugin.Ba3O1r8M.mjs';
 
 const EMPTY_THEME = {
   colors: [],
@@ -266,26 +266,6 @@ function scanCustomPropertyNames(block) {
   return names;
 }
 
-const LEADING_WHITESPACE_RE = /^\s+/;
-const LINE_COMMENT_RE = /^\/\/[^\n]*(?:\n|$)/;
-const BLOCK_COMMENT_RE = /^\/\*[\s\S]*?\*\//;
-const USE_DIRECTIVE_RE = /^['"]use (?:client|server)['"];?\s*/;
-function insertAfterUseDirective(code, insertion) {
-  let offset = 0;
-  while (offset < code.length) {
-    const triviaLength = leadingTriviaLength(code.slice(offset));
-    if (triviaLength === 0) break;
-    offset += triviaLength;
-  }
-  const directive = USE_DIRECTIVE_RE.exec(code.slice(offset));
-  if (!directive) return `${insertion}${code}`;
-  const insertionOffset = offset + directive[0].length;
-  return `${code.slice(0, insertionOffset)}${insertion}${code.slice(insertionOffset)}`;
-}
-function leadingTriviaLength(source) {
-  return LEADING_WHITESPACE_RE.exec(source)?.[0].length ?? LINE_COMMENT_RE.exec(source)?.[0].length ?? BLOCK_COMMENT_RE.exec(source)?.[0].length ?? 0;
-}
-
 const VIRTUAL_MODULE_ID = "virtual:csszyx/mangle-map";
 const RESOLVED_VIRTUAL_MODULE_ID = `\0${VIRTUAL_MODULE_ID}`;
 const THEME_GROUPS_VIRTUAL_ID = "virtual:csszyx/theme-groups";
@@ -330,7 +310,7 @@ export default checksum;
 `;
 }
 function isVirtualModule(id) {
-  return id === VIRTUAL_MODULE_ID || id === VIRTUAL_CHECKSUM_ID || id === THEME_GROUPS_VIRTUAL_ID || id === MANGLE_RUNTIME_VIRTUAL_ID;
+  return id === VIRTUAL_MODULE_ID || id === VIRTUAL_CHECKSUM_ID || id === THEME_GROUPS_VIRTUAL_ID || id === MANGLE_RUNTIME_VIRTUAL_ID || id === UNSERVED_VIRTUAL_ID;
 }
 function resolveVirtualModule(id) {
   if (id === VIRTUAL_MODULE_ID) {
@@ -345,14 +325,32 @@ function resolveVirtualModule(id) {
   if (id === MANGLE_RUNTIME_VIRTUAL_ID) {
     return RESOLVED_MANGLE_RUNTIME_VIRTUAL_ID;
   }
+  if (id === UNSERVED_VIRTUAL_ID) {
+    return RESOLVED_UNSERVED_VIRTUAL_ID;
+  }
   return void 0;
 }
 const MANGLE_RUNTIME_VIRTUAL_ID = "virtual:csszyx/mangle-runtime";
 const RESOLVED_MANGLE_RUNTIME_VIRTUAL_ID = `\0${MANGLE_RUNTIME_VIRTUAL_ID}`;
+const UNSERVED_VIRTUAL_ID = "virtual:csszyx/unserved";
+const RESOLVED_UNSERVED_VIRTUAL_ID = `\0${UNSERVED_VIRTUAL_ID}`;
 const MANGLE_MAP_PLACEHOLDER = "___CSSZYX_MANGLE_MAP___";
 const CENSUS_PLACEHOLDER = "___CSSZYX_CENSUS___";
 const VAR_MANGLE_MAP_PLACEHOLDER = "___CSSZYX_VAR_MANGLE_MAP___";
 const CHECKSUM_PLACEHOLDER = "___CSSZYX_CHECKSUM___";
+const UNSERVED_PLACEHOLDER = "___CSSZYX_UNSERVED___";
+function createUnservedRuntimeModule(classes) {
+  return `/**
+ * Auto-generated by csszyx: registers the class names this project's Tailwind
+ * produces no CSS for.
+ *
+ * @generated
+ */
+import { registerUnservedClasses } from '@csszyx/runtime';
+
+registerUnservedClasses(${classes === void 0 ? UNSERVED_PLACEHOLDER : JSON.stringify(classes)});
+`;
+}
 function createMangleRuntimeModule(globalVarAliasPrefix, exposeDebugGlobal = false) {
   return `/**
  * Auto-generated by csszyx: registers the runtime mangle map from the bundle.
@@ -389,94 +387,6 @@ function createThemeGroupsModule(tokens) {
   ].join("\n");
 }
 
-const RUNTIME_IMPORT_CLAUSE_RE = /(?:import|export)\s+\{([^{}]*)\}\s*from\s*['"]@csszyx\/runtime['"]/g;
-function clauseNames(clauseBody) {
-  const names = [];
-  for (const part of clauseBody.split(",")) {
-    const trimmed = part.trim();
-    if (!trimmed) {
-      continue;
-    }
-    const spaceAt = trimmed.search(/\s/);
-    names.push(spaceAt === -1 ? trimmed : trimmed.slice(0, spaceAt));
-  }
-  return names;
-}
-function importsRuntimeHelper(code, helper) {
-  RUNTIME_IMPORT_CLAUSE_RE.lastIndex = 0;
-  for (let match = RUNTIME_IMPORT_CLAUSE_RE.exec(code); match; match = RUNTIME_IMPORT_CLAUSE_RE.exec(code)) {
-    if (clauseNames(match[1]).includes(helper)) {
-      return true;
-    }
-  }
-  return false;
-}
-const RUNTIME_IMPORT_APPEND_RE = /(import\s+\{[^{}]*)\}\s*from\s*['"]@csszyx\/runtime['"]/;
-function findRuntimeImportClause(code) {
-  const match = RUNTIME_IMPORT_APPEND_RE.exec(code);
-  return match ? { statement: match[0], prefixWithBody: match[1] } : null;
-}
-
-function runtimeHelperGroupsFromUsage(usage) {
-  const slim = usage.usesSzPart === true && usage.szPartArgsProvable === true && usage.usesRuntime !== true && usage.usesMerge !== true;
-  const groups = { all: [], barrel: [], merge: [] };
-  const append = (helper, toMerge = false) => {
-    groups.all.push(helper);
-    (toMerge ? groups.merge : groups.barrel).push(helper);
-  };
-  if (usage.usesRuntime) append("_sz");
-  if (usage.usesMerge) append("_szMerge");
-  if (usage.usesSzcn) append("_szcn", slim);
-  if (usage.usesSzPart) append("_szPart", slim);
-  if (usage.usesSzvPick) append("__szvPick");
-  if (usage.usesSzvPick1) append("__szvPick1");
-  if (usage.usesColorVar) append("__szColorVar");
-  if (usage.usesSpacingVar) append("__szSpacingVar");
-  if (usage.usesUnitVar) append("__szUnitVar");
-  if (usage.usesBoolClass) append("__szBoolClass");
-  return groups;
-}
-function injectNextRuntimeImports(code, usage) {
-  const groups = runtimeHelperGroupsFromUsage(usage);
-  const helpers = groups.all;
-  if (helpers.length === 0) {
-    return { code, injected: [] };
-  }
-  const hasRuntimeImport = code.includes("@csszyx/runtime");
-  const missing = hasRuntimeImport ? helpers.filter((helper) => !importsRuntimeHelper(code, helper)) : helpers;
-  if (missing.length === 0) {
-    return { code, injected: [] };
-  }
-  if (groups.merge.length > 0) {
-    const mergeHelpers = missing.filter((helper) => groups.merge.includes(helper));
-    const barrelHelpers = missing.filter((helper) => groups.barrel.includes(helper));
-    let next = insertRuntimeImport(
-      code,
-      `import { ${mergeHelpers.join(", ")} } from '@csszyx/runtime/merge';
-`
-    );
-    if (barrelHelpers.length > 0) {
-      next = insertRuntimeImport(
-        next,
-        `import { ${barrelHelpers.join(", ")} } from '@csszyx/runtime';
-`
-      );
-    }
-    return { code: next, injected: missing };
-  }
-  return {
-    code: insertRuntimeImport(
-      code,
-      `import { ${missing.join(", ")} } from '@csszyx/runtime';
-`
-    ),
-    injected: missing
-  };
-}
-function insertRuntimeImport(code, importStmt) {
-  return insertAfterUseDirective(code, importStmt);
-}
-
 const THEME_SCAN_IGNORE_DIRS = /* @__PURE__ */ new Set([
   "node_modules",
   ".next",
@@ -587,4 +497,4 @@ function themeGroupsSpecifier(fromFile, themeGroupsFile) {
   return relative.startsWith("./") || relative.startsWith("../") ? relative : `./${relative}`;
 }
 
-export { CHECKSUM_PLACEHOLDER as C, MANGLE_RUNTIME_VIRTUAL_ID as M, RESOLVED_VIRTUAL_MODULE_ID as R, THEME_GROUPS_VIRTUAL_ID as T, VAR_MANGLE_MAP_PLACEHOLDER as V, parseUtilityBlocks as a, insertAfterUseDirective as b, createMangleRuntimeModule as c, createMangleMapModule as d, ensureThemeGroupsFile as e, RESOLVED_VIRTUAL_CHECKSUM_ID as f, createChecksumModule as g, hasTokens as h, injectNextRuntimeImports as i, RESOLVED_MANGLE_RUNTIME_VIRTUAL_ID as j, RESOLVED_THEME_GROUPS_VIRTUAL_ID as k, createThemeGroupsModule as l, mergeThemes as m, isVirtualModule as n, discoverProjectTheme as o, parseThemeBlocks as p, CENSUS_PLACEHOLDER as q, resolveVirtualModule as r, scanCustomPropertyNames as s, themeGroupsSpecifier as t, importsRuntimeHelper as u, findRuntimeImportClause as v, THEME_GROUPS_FILE_MARKER as w, runtimeHelperGroupsFromUsage as x, MANGLE_MAP_PLACEHOLDER as y };
+export { CHECKSUM_PLACEHOLDER as C, MANGLE_RUNTIME_VIRTUAL_ID as M, RESOLVED_VIRTUAL_MODULE_ID as R, THEME_GROUPS_VIRTUAL_ID as T, UNSERVED_VIRTUAL_ID as U, VAR_MANGLE_MAP_PLACEHOLDER as V, parseUtilityBlocks as a, createUnservedRuntimeModule as b, createMangleRuntimeModule as c, createMangleMapModule as d, ensureThemeGroupsFile as e, RESOLVED_VIRTUAL_CHECKSUM_ID as f, createChecksumModule as g, hasTokens as h, RESOLVED_MANGLE_RUNTIME_VIRTUAL_ID as i, RESOLVED_UNSERVED_VIRTUAL_ID as j, RESOLVED_THEME_GROUPS_VIRTUAL_ID as k, createThemeGroupsModule as l, mergeThemes as m, isVirtualModule as n, discoverProjectTheme as o, parseThemeBlocks as p, CENSUS_PLACEHOLDER as q, resolveVirtualModule as r, scanCustomPropertyNames as s, themeGroupsSpecifier as t, THEME_GROUPS_FILE_MARKER as u, UNSERVED_PLACEHOLDER as v, MANGLE_MAP_PLACEHOLDER as w };

package/dist/shared/{unplugin.COlI0dJs.d.mts → unplugin.C_2R8vIk.d.cts}

@@ -1,4 +1,4 @@
-import { a as NextSafelistMaterializeResult, b as NextSafelistStateLockOptions, A as AtomicWriteOptions } from './unplugin.BGog1Bib.mjs';
+import { a as NextSafelistMaterializeResult, b as NextSafelistStateLockOptions, A as AtomicWriteOptions } from './unplugin.XdPo6azz.cjs';
 
 /** Options for one synchronous watcher materialization cycle. */
 interface NextWatcherCycleOptions {