@csszyx/unplugin 0.17.0 → 0.17.1

package/dist/next-watcher.mjs

@@ -1,5 +1,6 @@
 import * as path from 'node:path';
-import { r as runNextWatcherCycle } from './shared/unplugin.DPSQP5XG.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.Ba3O1r8M.mjs';
 import 'node:crypto';
@@ -7,6 +8,12 @@ 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;
@@ -14,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;
   /**
@@ -31,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;
   }
   /**
    *
@@ -54,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);
   }
   /**
    *
@@ -75,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;
+    }
+  }
   /**
    *
    */
@@ -86,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;
+  }
   /**
    *
    */
@@ -100,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;
   }
 }
@@ -153,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) {
@@ -163,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.alhYXymJ.cjs → unplugin.BKID6KXV.cjs}

@@ -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.995yC_cN.mjs → unplugin.CK-DfKTP.mjs}

@@ -310,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) {
@@ -325,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.
@@ -479,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, createMangleMapModule as b, createMangleRuntimeModule as c, RESOLVED_VIRTUAL_CHECKSUM_ID as d, ensureThemeGroupsFile as e, createChecksumModule as f, RESOLVED_MANGLE_RUNTIME_VIRTUAL_ID as g, hasTokens as h, RESOLVED_THEME_GROUPS_VIRTUAL_ID as i, createThemeGroupsModule as j, isVirtualModule as k, discoverProjectTheme as l, mergeThemes as m, CENSUS_PLACEHOLDER as n, THEME_GROUPS_FILE_MARKER as o, parseThemeBlocks as p, MANGLE_MAP_PLACEHOLDER as q, resolveVirtualModule as r, scanCustomPropertyNames as s, themeGroupsSpecifier as t };
+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 {