feat(extractor): add extract_with_context() for stateless extraction

Add sync methods to ExtractionContext for global state interop:
- sync_to_globals(): push context state to global variables
- sync_from_globals(): pull global state back to context
- from_globals(): create context from current global state

Add extract_with_context() function that wraps extract() with
context synchronization, enabling stateless extraction for
parallel processing (e.g., Turbopack multi-core builds).

This is an incremental approach - internal modules still use
global state, but the new API provides the foundation for
future parallelization work.

Author: owjs3901

libs/extractor/src/context.rs

@@ -180,6 +180,43 @@ impl ExtractionContext {
     }
 }
 
+/// Synchronize context with global state (for incremental migration).
+///
+/// This allows using ExtractionContext while the codebase still uses global
+/// state internally. Once the full migration is complete, this can be removed.
+impl ExtractionContext {
+    /// Populate global state from this context.
+    ///
+    /// Call this before extraction to set up the global state.
+    pub fn sync_to_globals(&self) {
+        css::class_map::set_class_map(self.class_map.clone());
+        css::file_map::set_file_map(self.file_map.clone());
+        css::set_prefix(self.prefix.clone());
+        css::debug::set_debug(self.debug);
+    }
+
+    /// Populate this context from global state.
+    ///
+    /// Call this after extraction to capture any state changes.
+    pub fn sync_from_globals(&mut self) {
+        self.class_map = css::class_map::get_class_map();
+        self.file_map = css::file_map::get_file_map();
+        self.prefix = css::get_prefix();
+        self.debug = css::debug::is_debug();
+    }
+
+    /// Create a context initialized from current global state.
+    #[must_use]
+    pub fn from_globals() -> Self {
+        Self {
+            class_map: css::class_map::get_class_map(),
+            file_map: css::file_map::get_file_map(),
+            prefix: css::get_prefix(),
+            debug: css::debug::is_debug(),
+        }
+    }
+}
+
 #[cfg(test)]
 mod tests {
     use super::*;

libs/extractor/src/lib.rs

@@ -268,6 +268,50 @@ pub fn extract(
     })
 }
 
+/// Extract styles from code using an explicit context instead of global state.
+///
+/// This function enables stateless extraction for parallel processing (e.g., Turbopack).
+/// It synchronizes the context with global state before extraction and captures any
+/// state changes afterward.
+///
+/// # Arguments
+///
+/// * `filename` - The source file path (used for file-specific class prefixes)
+/// * `code` - The source code to extract styles from
+/// * `option` - Extraction options (package name, CSS directory, etc.)
+/// * `ctx` - Mutable reference to the extraction context
+///
+/// # Example
+///
+/// ```rust,ignore
+/// use extractor::{ExtractionContext, extract_with_context, ExtractOption};
+///
+/// let mut ctx = ExtractionContext::new();
+/// let result = extract_with_context(
+///     "component.tsx",
+///     r#"import { Box } from '@devup-ui/react'; export default () => <Box bg="red" />"#,
+///     ExtractOption::default(),
+///     &mut ctx,
+/// )?;
+/// ```
+pub fn extract_with_context(
+    filename: &str,
+    code: &str,
+    option: ExtractOption,
+    ctx: &mut ExtractionContext,
+) -> Result<ExtractOutput, Box<dyn Error>> {
+    // Sync context state to globals before extraction
+    ctx.sync_to_globals();
+
+    // Perform extraction using existing implementation
+    let result = extract(filename, code, option);
+
+    // Capture any state changes back to context
+    ctx.sync_from_globals();
+
+    result
+}
+
 /// Extract class names from generated code for specific style names
 /// Used for two-pass vanilla-extract processing to resolve selector references
 pub fn extract_class_map_from_code(