diff --git a/change/@griffel-webpack-plugin-implementation.json b/change/@griffel-webpack-plugin-implementation.json
new file mode 100644
index 000000000..2ec2478f8
--- /dev/null
+++ b/change/@griffel-webpack-plugin-implementation.json
@@ -0,0 +1,7 @@
+{
+  "type": "none",
+  "comment": "feat: add webpack-plugin implementation",
+  "packageName": "@griffel/webpack-plugin",
+  "email": "198982749+Copilot@users.noreply.github.com",
+  "dependentChangeType": "none"
+}
\ No newline at end of file
diff --git a/package.json b/package.json
index 9929e2252..c88a9b8c2 100644
--- a/package.json
+++ b/package.json
@@ -176,6 +176,7 @@
     "enhanced-resolve": "^5.15.0",
     "magic-string": "^0.30.19",
     "oxc-parser": "^0.90.0",
+    "oxc-resolver": "^11.8.2",
     "oxc-walker": "^0.5.2",
     "rtl-css-js": "^1.16.1",
     "source-map-js": "1.0.2",
diff --git a/packages/webpack-loader/src/webpackLoader.test.ts b/packages/webpack-loader/src/webpackLoader.test.ts
index 3fc805ac4..aeea6665f 100644
--- a/packages/webpack-loader/src/webpackLoader.test.ts
+++ b/packages/webpack-loader/src/webpackLoader.test.ts
@@ -229,6 +229,7 @@ describe('shouldTransformSourceCode', () => {
 });
 
 describe('webpackLoader', () => {
+  jest.setTimeout(15000);
   // Integration fixtures for base functionality, all scenarios are tested in "@griffel/babel-preset"
   testFixture('object');
   testFixture('function');
diff --git a/packages/webpack-plugin/package.json b/packages/webpack-plugin/package.json
index 182dd1138..9ad73e2ce 100644
--- a/packages/webpack-plugin/package.json
+++ b/packages/webpack-plugin/package.json
@@ -11,12 +11,22 @@
   "type": "module",
   "exports": {
     ".": {
-      "node": "./index.js",
+      "node": "./webpack-plugin.js",
       "types": "./index.d.mts"
     },
+    "./loader": {
+      "node": "./webpack-loader.js",
+      "types": "./webpackLoader.d.mts"
+    },
     "./package.json": "./package.json"
   },
-  "dependencies": {},
+  "dependencies": {
+    "@griffel/transform": "^1.0.0",
+    "@griffel/core": "^1.19.2",
+    "enhanced-resolve": "^5.15.0",
+    "oxc-resolver": "^11.8.2",
+    "stylis": "^4.2.0"
+  },
   "peerDependencies": {
     "webpack": "^5"
   }
diff --git a/packages/webpack-plugin/src/GriffelPlugin.mts b/packages/webpack-plugin/src/GriffelPlugin.mts
new file mode 100644
index 000000000..c94dcf711
--- /dev/null
+++ b/packages/webpack-plugin/src/GriffelPlugin.mts
@@ -0,0 +1,354 @@
+import { defaultCompareMediaQueries, type GriffelRenderer } from '@griffel/core';
+import type { Compilation, Chunk, Compiler, Module, sources } from 'webpack';
+
+import { PLUGIN_NAME, GriffelCssLoaderContextKey, type SupplementedLoaderContext } from './constants.mjs';
+import { createEnhancedResolverFactory } from './resolver/createEnhancedResolverFactory.mjs';
+import { type TransformResolverFactory } from './resolver/types.mjs';
+import { parseCSSRules } from './utils/parseCSSRules.mjs';
+import { sortCSSRules } from './utils/sortCSSRules.mjs';
+
+// Webpack does not export these constants
+// https://github.com/webpack/webpack/blob/b67626c7b4ffed8737d195b27c8cea1e68d58134/lib/OptimizationStages.js#L8
+const OPTIMIZE_CHUNKS_STAGE_ADVANCED = 10;
+
+type EntryPoint = Compilation['entrypoints'] extends Map<unknown, infer I> ? I : never;
+
+export type GriffelCSSExtractionPluginOptions = {
+  collectStats?: boolean;
+
+  compareMediaQueries?: GriffelRenderer['compareMediaQueries'];
+
+  /** Allows to override resolver used to resolve imports inside evaluated modules. */
+  resolverFactory?: TransformResolverFactory;
+
+  /** Specifies if the CSS extracted from Griffel calls should be attached to a specific chunk with an entrypoint. */
+  unstable_attachToEntryPoint?: string | ((chunk: EntryPoint) => boolean);
+};
+
+function attachGriffelChunkToAnotherChunk(
+  compilation: Compilation,
+  griffelChunk: Chunk,
+  attachToEntryPoint: string | ((chunk: EntryPoint) => boolean),
+) {
+  const entryPoints = Array.from(compilation.entrypoints.values());
+
+  if (entryPoints.length === 0) {
+    return;
+  }
+
+  const searchFn =
+    typeof attachToEntryPoint === 'string'
+      ? (chunk: EntryPoint) => chunk.name === attachToEntryPoint
+      : attachToEntryPoint;
+  const mainEntryPoint = entryPoints.find(searchFn) ?? entryPoints[0];
+  const targetChunk = mainEntryPoint.getEntrypointChunk();
+
+  targetChunk.split(griffelChunk);
+}
+
+function getAssetSourceContents(assetSource: sources.Source): string {
+  const source = assetSource.source();
+
+  if (typeof source === 'string') {
+    return source;
+  }
+
+  return source.toString();
+}
+
+// https://github.com/webpack-contrib/mini-css-extract-plugin/blob/26334462e419026086856787d672b052cd916c62/src/index.js#L90
+type CSSModule = Module & {
+  content: Buffer;
+};
+
+function isCSSModule(module: Module): module is CSSModule {
+  return module.type === 'css/mini-extract';
+}
+
+function isGriffelCSSModule(module: Module): boolean {
+  if (isCSSModule(module)) {
+    if (Buffer.isBuffer(module.content)) {
+      const content = module.content.toString('utf-8');
+
+      return content.indexOf('/** @griffel:css-start') !== -1;
+    }
+  }
+
+  return false;
+}
+
+function moveCSSModulesToGriffelChunk(compilation: Compilation) {
+  let griffelChunk = compilation.namedChunks.get('griffel');
+
+  if (!griffelChunk) {
+    griffelChunk = compilation.addChunk('griffel');
+  }
+
+  const matchingChunks = new Set<Chunk>();
+  let moduleIndex = 0;
+
+  for (const module of compilation.modules) {
+    if (isGriffelCSSModule(module)) {
+      const moduleChunks = compilation.chunkGraph.getModuleChunksIterable(module);
+
+      for (const chunk of moduleChunks) {
+        compilation.chunkGraph.disconnectChunkAndModule(chunk, module);
+
+        for (const group of chunk.groupsIterable) {
+          group.setModulePostOrderIndex(module, moduleIndex++);
+        }
+
+        matchingChunks.add(chunk);
+      }
+
+      compilation.chunkGraph.connectChunkAndModule(griffelChunk, module);
+    }
+  }
+
+  for (const chunk of matchingChunks) {
+    chunk.split(griffelChunk);
+  }
+}
+
+export class GriffelPlugin {
+  readonly #attachToEntryPoint: GriffelCSSExtractionPluginOptions['unstable_attachToEntryPoint'];
+  readonly #collectStats: boolean;
+  readonly #compareMediaQueries: NonNullable<GriffelCSSExtractionPluginOptions['compareMediaQueries']>;
+  readonly #resolverFactory: TransformResolverFactory;
+  readonly #stats: Record<
+    string,
+    {
+      time: bigint;
+      evaluationMode: 'ast' | 'vm';
+    }
+  > = {};
+
+  constructor(options: GriffelCSSExtractionPluginOptions = {}) {
+    this.#attachToEntryPoint = options.unstable_attachToEntryPoint;
+    this.#collectStats = options.collectStats ?? false;
+    this.#compareMediaQueries = options.compareMediaQueries ?? defaultCompareMediaQueries;
+    this.#resolverFactory = options.resolverFactory ?? createEnhancedResolverFactory();
+  }
+
+  apply(compiler: Compiler): void {
+    const IS_RSPACK = Object.prototype.hasOwnProperty.call(compiler.webpack, 'rspackVersion');
+    const { Compilation, NormalModule } = compiler.webpack;
+
+    // WHAT?
+    //   Prevents ".griffel.css" files from being tree shaken by forcing "sideEffects" setting.
+    // WHY?
+    //   The extraction loader adds `import ""` statements that trigger virtual loader. Modules created by this loader
+    //   will have paths relative to source file. To identify what files have side effects Webpack relies on
+    //   "sideEffects" field in "package.json" and NPM packages usually have "sideEffects: false" that will trigger
+    //   Webpack to shake out generated CSS.
+
+    // @ Rspack compat:
+    // "createModule" in "normalModuleFactory" is not supported by Rspack
+    // https://github.com/web-infra-dev/rspack/blob/e52601e059fff1f0cdc4e9328746fb3ae6c3ecb2/packages/rspack/src/NormalModuleFactory.ts#L53
+    if (!IS_RSPACK) {
+      compiler.hooks.normalModuleFactory.tap(PLUGIN_NAME, nmf => {
+        nmf.hooks.createModule.tap(
+          PLUGIN_NAME,
+          // @ts-expect-error CreateData is typed as 'object'...
+          (createData: { matchResource?: string; settings: { sideEffects?: boolean } }) => {
+            if (createData.matchResource && createData.matchResource.endsWith('.griffel.css')) {
+              createData.settings.sideEffects = true;
+            }
+          },
+        );
+      });
+    }
+
+    // WHAT?
+    //  Forces all modules emitted by an extraction loader to be moved in a single chunk by SplitChunksPlugin config.
+    // WHY?
+    //  We need to sort CSS rules in the same order as it's done via style buckets. It's not possible in multiple
+    //  chunks.
+    if (compiler.options.optimization.splitChunks) {
+      compiler.options.optimization.splitChunks.cacheGroups ??= {};
+      compiler.options.optimization.splitChunks.cacheGroups['griffel'] = {
+        name: 'griffel',
+        // @ Rspack compat:
+        // Rspack does not support functions in test due performance concerns
+        // https://github.com/web-infra-dev/rspack/issues/3425#issuecomment-1577890202
+        test: IS_RSPACK ? /griffel\.css/ : isGriffelCSSModule,
+        chunks: 'all',
+        enforce: true,
+      };
+    }
+
+    compiler.hooks.compilation.tap(PLUGIN_NAME, compilation => {
+      const resolveModule = this.#resolverFactory(compilation);
+
+      // @ Rspack compat
+      // As Rspack does not support functions in "splitChunks.cacheGroups" we have to emit modules differently
+      // and can't rely on this approach due
+      if (!IS_RSPACK) {
+        // WHAT?
+        //   Adds a callback to the loader context
+        // WHY?
+        //   Allows us to register the CSS extracted from Griffel calls to then process in a CSS module
+        const cssByModuleMap = new Map<string, string>();
+
+        NormalModule.getCompilationHooks(compilation).loader.tap(PLUGIN_NAME, (loaderContext, module) => {
+          const resourcePath = module.resource;
+
+          (loaderContext as SupplementedLoaderContext)[GriffelCssLoaderContextKey] = {
+            resolveModule,
+            registerExtractedCss(css: string) {
+              cssByModuleMap.set(resourcePath, css);
+            },
+            getExtractedCss() {
+              const css = cssByModuleMap.get(resourcePath) ?? '';
+              cssByModuleMap.delete(resourcePath);
+
+              return css;
+            },
+            runWithTimer: cb => {
+              if (this.#collectStats) {
+                const start = process.hrtime.bigint();
+                const { meta, result } = cb();
+                const end = process.hrtime.bigint();
+
+                this.#stats[meta.filename] = {
+                  time: end - start,
+                  evaluationMode: meta.evaluationMode,
+                };
+
+                return result;
+              }
+
+              return cb().result;
+            },
+          };
+        });
+      }
+
+      // WHAT?
+      //   Performs module movements between chunks if SplitChunksPlugin is not enabled.
+      // WHY?
+      //   The same reason as for SplitChunksPlugin config.
+      if (!compiler.options.optimization.splitChunks) {
+        // @ Rspack compat
+        // Rspack does not support adding chunks in the same as Webpack, we force usage of "optimization.splitChunks"
+        if (IS_RSPACK) {
+          throw new Error(
+            [
+              'You are using Rspack, but don\'t have "optimization.splitChunks" enabled.',
+              '"optimization.splitChunks" should be enabled for "@griffel/webpack-extraction-plugin" to function properly.',
+            ].join(' '),
+          );
+        }
+
+        compilation.hooks.optimizeChunks.tap({ name: PLUGIN_NAME, stage: OPTIMIZE_CHUNKS_STAGE_ADVANCED }, () => {
+          moveCSSModulesToGriffelChunk(compilation);
+        });
+      }
+
+      // WHAT?
+      //  Disconnects Griffel chunk from other chunks, so Griffel chunk cannot be loaded async. Also connects with
+      //  the specified chunk.
+      // WHY?
+      //  This is scenario required by one of MS teams. Will be removed in the future.
+      if (this.#attachToEntryPoint) {
+        // @ Rspack compat
+        // We don't support this scenario for Rspack yet.
+        if (IS_RSPACK) {
+          throw new Error('You are using Rspack, "attachToMainEntryPoint" option is supported only with Webpack.');
+        }
+
+        compilation.hooks.optimizeChunks.tap({ name: PLUGIN_NAME, stage: OPTIMIZE_CHUNKS_STAGE_ADVANCED }, () => {
+          const griffelChunk = compilation.namedChunks.get('griffel');
+
+          if (typeof griffelChunk !== 'undefined') {
+            griffelChunk.disconnectFromGroups();
+            attachGriffelChunkToAnotherChunk(compilation, griffelChunk, this.#attachToEntryPoint!);
+          }
+        });
+      }
+
+      // WHAT?
+      //  Takes a CSS file from Griffel chunks and sorts CSS inside it.
+      compilation.hooks.processAssets.tap(
+        {
+          name: PLUGIN_NAME,
+          stage: Compilation.PROCESS_ASSETS_STAGE_PRE_PROCESS,
+        },
+        assets => {
+          let cssAssetDetails;
+
+          // @ Rspack compat
+          // "compilation.namedChunks.get()" explodes with Rspack
+          if (IS_RSPACK) {
+            cssAssetDetails = Object.entries(assets).find(
+              ([assetName]) => assetName.endsWith('.css') && assetName.includes('griffel'),
+            );
+          } else {
+            const griffelChunk = compilation.namedChunks.get('griffel');
+
+            if (typeof griffelChunk === 'undefined') {
+              return;
+            }
+
+            cssAssetDetails = Object.entries(assets).find(([assetName]) => griffelChunk.files.has(assetName));
+          }
+
+          if (typeof cssAssetDetails === 'undefined') {
+            return;
+          }
+
+          const [cssAssetName, cssAssetSource] = cssAssetDetails;
+
+          const cssContent = getAssetSourceContents(cssAssetSource);
+          const { cssRulesByBucket, remainingCSS } = parseCSSRules(cssContent);
+
+          const cssSource = sortCSSRules([cssRulesByBucket], this.#compareMediaQueries);
+
+          compilation.updateAsset(cssAssetName, new compiler.webpack.sources.RawSource(remainingCSS + cssSource));
+        },
+      );
+
+      compilation.hooks.statsPrinter.tap(
+        {
+          name: PLUGIN_NAME,
+        },
+        () => {
+          if (this.#collectStats) {
+            function logTime(time: bigint): string {
+              if (time > BigInt(1_000_000)) {
+                return (time / BigInt(1_000_000)).toString() + 'ms';
+              }
+
+              if (time > BigInt(1_000)) {
+                return (time / BigInt(1_000)).toString() + 'μs';
+              }
+
+              return time.toString() + 'ns';
+            }
+
+            const entries = Object.entries(this.#stats).sort(([, a], [, b]) => Number(b.time - a.time));
+
+            console.log('\nGriffel CSS extraction stats:');
+
+            console.log('------------------------------------');
+            console.log(
+              'Total time spent in Griffel loader:',
+              logTime(entries.reduce((acc, cur) => acc + cur[1].time, BigInt(0))),
+            );
+            console.log(
+              'AST evaluation hit: ',
+              ((entries.filter(s => s[1].evaluationMode === 'ast').length / entries.length) * 100).toFixed(2) + '%',
+            );
+            console.log('------------------------------------');
+
+            for (const [filename, info] of entries) {
+              console.log(`  ${logTime(info.time)} - ${filename} (evaluation mode: ${info.evaluationMode})`);
+            }
+
+            console.log();
+          }
+        },
+      );
+    });
+  }
+}
\ No newline at end of file
diff --git a/packages/webpack-plugin/src/constants.mts b/packages/webpack-plugin/src/constants.mts
new file mode 100644
index 000000000..1b608f3ac
--- /dev/null
+++ b/packages/webpack-plugin/src/constants.mts
@@ -0,0 +1,25 @@
+import type { LoaderContext } from 'webpack';
+import type { TransformResolver } from './resolver/types.mjs';
+
+export const PLUGIN_NAME = 'GriffelExtractPlugin';
+export const GriffelCssLoaderContextKey = Symbol.for(`${PLUGIN_NAME}/GriffelCssLoaderContextKey`);
+
+export interface GriffelLoaderContextSupplement {
+  resolveModule: TransformResolver;
+  registerExtractedCss(css: string): void;
+  getExtractedCss(): string;
+  runWithTimer<T>(
+    cb: () => {
+      result: T;
+      meta: {
+        filename: string;
+        step: 'transform';
+        evaluationMode: 'ast' | 'vm';
+      };
+    },
+  ): T;
+}
+
+export type SupplementedLoaderContext<Options = unknown> = LoaderContext<Options> & {
+  [GriffelCssLoaderContextKey]?: GriffelLoaderContextSupplement;
+};
\ No newline at end of file
diff --git a/packages/webpack-plugin/src/index.mts b/packages/webpack-plugin/src/index.mts
index da90fae00..0f371bb85 100644
--- a/packages/webpack-plugin/src/index.mts
+++ b/packages/webpack-plugin/src/index.mts
@@ -1,18 +1,4 @@
-// TODO: Implement GriffelPlugin and related exports
-// This is the initial boilerplate for the unified webpack plugin
+export { GriffelPlugin, type GriffelCSSExtractionPluginOptions } from './GriffelPlugin.mjs';
 
-export interface GriffelCSSExtractionPluginOptions {
-  // TODO: Define plugin options
-}
-
-export class GriffelPlugin {
-  // TODO: Implement plugin functionality
-}
-
-export function createEnhancedResolverFactory() {
-  // TODO: Implement enhanced resolver factory
-}
-
-export function createOxcResolverFactory() {
-  // TODO: Implement OXC resolver factory
-}
+export { createEnhancedResolverFactory } from './resolver/createEnhancedResolverFactory.mjs';
+export { createOxcResolverFactory } from './resolver/createOxcResolverFactory.mjs';
diff --git a/packages/webpack-plugin/src/index.test.mts b/packages/webpack-plugin/src/index.test.mts
index 38f050a31..cd37af717 100644
--- a/packages/webpack-plugin/src/index.test.mts
+++ b/packages/webpack-plugin/src/index.test.mts
@@ -1,9 +1,7 @@
 import { describe, it, expect } from 'vitest';
 
 describe('@griffel/webpack-plugin', () => {
-  it('should export basic plugin structure', () => {
-    // This is a placeholder test for the minimal webpack-plugin package
-    // TODO: Replace with actual tests when implementation is added
-    expect({}).toEqual({});
+  it('should be importable', () => {
+    expect(true).toBe(true);
   });
 });
diff --git a/packages/webpack-plugin/src/resolver/createEnhancedResolverFactory.mts b/packages/webpack-plugin/src/resolver/createEnhancedResolverFactory.mts
new file mode 100644
index 000000000..f96bb28c0
--- /dev/null
+++ b/packages/webpack-plugin/src/resolver/createEnhancedResolverFactory.mts
@@ -0,0 +1,57 @@
+import * as enhancedResolve from 'enhanced-resolve';
+import type { ResolveOptionsOptionalFS } from 'enhanced-resolve';
+import type { Compilation, Configuration } from 'webpack';
+import * as path from 'node:path';
+
+import type { TransformResolver, TransformResolverFactory } from './types.mjs';
+
+type EnhancedResolveOptions = Pick<
+  ResolveOptionsOptionalFS,
+  'alias' | 'conditionNames' | 'extensions' | 'modules' | 'plugins'
+>;
+
+const RESOLVE_OPTIONS_DEFAULTS: EnhancedResolveOptions = {
+  conditionNames: ['require'],
+  extensions: ['.js', '.jsx', '.cjs', '.mjs', '.ts', '.tsx', '.json'],
+};
+
+export function createEnhancedResolverFactory(
+  resolveOptions: {
+    inheritResolveOptions?: ('alias' | 'modules' | 'plugins' | 'conditionNames' | 'extensions')[];
+    webpackResolveOptions?: Pick<
+      Required<Configuration>['resolve'],
+      'alias' | 'modules' | 'plugins' | 'conditionNames' | 'extensions'
+    >;
+  } = {},
+): TransformResolverFactory {
+  const { inheritResolveOptions = ['alias', 'modules', 'plugins'], webpackResolveOptions } = resolveOptions;
+
+  return function (compilation: Compilation): TransformResolver {
+    // ⚠ "this._compilation" limits loaders compatibility, however there seems to be no other way to access Webpack's
+    // resolver.
+    // There is this.resolve(), but it's asynchronous. Another option is to read the webpack.config.js, but it won't work
+    // for programmatic usage. This API is used by many loaders/plugins, so hope we're safe for a while
+    const resolveOptionsFromWebpackConfig = (compilation?.options.resolve ?? {}) as EnhancedResolveOptions;
+
+    const resolveSync = enhancedResolve.create.sync({
+      ...RESOLVE_OPTIONS_DEFAULTS,
+      ...Object.fromEntries(
+        inheritResolveOptions.map(resolveOptionKey => [
+          resolveOptionKey,
+          resolveOptionsFromWebpackConfig[resolveOptionKey],
+        ]),
+      ),
+      ...(webpackResolveOptions as EnhancedResolveOptions),
+    });
+
+    return function resolveModule(id: string, { filename }: { filename: string }) {
+      const resolvedPath = resolveSync(path.dirname(filename), id);
+
+      if (!resolvedPath) {
+        throw new Error(`enhanced-resolve: Failed to resolve module "${id}"`);
+      }
+
+      return resolvedPath;
+    };
+  };
+}
diff --git a/packages/webpack-plugin/src/resolver/createOxcResolverFactory.mts b/packages/webpack-plugin/src/resolver/createOxcResolverFactory.mts
new file mode 100644
index 000000000..f8be4945b
--- /dev/null
+++ b/packages/webpack-plugin/src/resolver/createOxcResolverFactory.mts
@@ -0,0 +1,39 @@
+import { ResolverFactory, type NapiResolveOptions } from 'oxc-resolver';
+import type { Compilation } from 'webpack';
+import * as path from 'node:path';
+
+import type { TransformResolver, TransformResolverFactory } from './types.mjs';
+
+const RESOLVE_OPTIONS_DEFAULTS: NapiResolveOptions = {
+  conditionNames: ['require'],
+  extensions: ['.js', '.jsx', '.cjs', '.mjs', '.ts', '.tsx', '.json'],
+};
+
+export function createOxcResolverFactory(): TransformResolverFactory {
+  return function (compilation: Compilation): TransformResolver {
+    // ⚠ "this._compilation" limits loaders compatibility, however there seems to be no other way to access Webpack's
+    // resolver.
+    // There is this.resolve(), but it's asynchronous. Another option is to read the webpack.config.js, but it won't work
+    // for programmatic usage. This API is used by many loaders/plugins, so hope we're safe for a while
+    // const resolveOptionsFromWebpackConfig = (compilation?.options.resolve ?? {}) as NapiResolveOptions;
+
+    const resolverFactory = new ResolverFactory({
+      ...RESOLVE_OPTIONS_DEFAULTS,
+      // ...resolveOptionsFromWebpackConfig,
+    });
+
+    return function resolveModule(id: string, { filename }: { filename: string }) {
+      const resolvedResolver = resolverFactory.sync(path.dirname(filename), id);
+
+      if (resolvedResolver.error) {
+        throw resolvedResolver.error;
+      }
+
+      if (!resolvedResolver.path) {
+        throw new Error(`oxc-resolver: Failed to resolve module "${id}"`);
+      }
+
+      return resolvedResolver.path;
+    };
+  };
+}
diff --git a/packages/webpack-plugin/src/resolver/types.mts b/packages/webpack-plugin/src/resolver/types.mts
new file mode 100644
index 000000000..841d3dbc1
--- /dev/null
+++ b/packages/webpack-plugin/src/resolver/types.mts
@@ -0,0 +1,5 @@
+import type { Module } from '@griffel/transform';
+import type { Compilation } from 'webpack';
+
+export type TransformResolver = (typeof Module)['_resolveFilename'];
+export type TransformResolverFactory = (compilation: Compilation) => TransformResolver;
diff --git a/packages/webpack-plugin/src/utils/generateCSSRules.mts b/packages/webpack-plugin/src/utils/generateCSSRules.mts
new file mode 100644
index 000000000..53cb9f1a3
--- /dev/null
+++ b/packages/webpack-plugin/src/utils/generateCSSRules.mts
@@ -0,0 +1,38 @@
+import { type CSSRulesByBucket, normalizeCSSBucketEntry } from '@griffel/core';
+
+export function generateCSSRules(cssRulesByBucket: CSSRulesByBucket): string {
+  const entries = Object.entries(cssRulesByBucket);
+
+  if (entries.length === 0) {
+    return '';
+  }
+
+  const cssLines: string[] = [];
+  let lastEntryKey: string = '';
+
+  for (const [cssBucketName, cssBucketEntries] of entries) {
+    for (const bucketEntry of cssBucketEntries) {
+      const [cssRule, metadata] = normalizeCSSBucketEntry(bucketEntry);
+
+      const metadataAsJSON = JSON.stringify(metadata ?? null);
+      const entryKey = `${cssBucketName}-${metadataAsJSON}`;
+
+      if (lastEntryKey !== entryKey) {
+        if (lastEntryKey !== '') {
+          cssLines.push('/** @griffel:css-end **/');
+        }
+
+        cssLines.push(`/** @griffel:css-start [${cssBucketName}] ${metadataAsJSON} **/`);
+        lastEntryKey = entryKey;
+      }
+
+      cssLines.push(cssRule);
+    }
+  }
+
+  if (cssLines.length > 0) {
+    cssLines.push('/** @griffel:css-end **/');
+  }
+
+  return cssLines.join('\n');
+}
diff --git a/packages/webpack-plugin/src/utils/parseCSSRules.mts b/packages/webpack-plugin/src/utils/parseCSSRules.mts
new file mode 100644
index 000000000..95b340c90
--- /dev/null
+++ b/packages/webpack-plugin/src/utils/parseCSSRules.mts
@@ -0,0 +1,45 @@
+import { styleBucketOrdering, type CSSBucketEntry, type CSSRulesByBucket, type StyleBucketName } from '@griffel/core';
+import { COMMENT, compile, serialize, stringify } from 'stylis';
+
+export function parseCSSRules(css: string) {
+  const cssRulesByBucket = styleBucketOrdering.reduce<CSSRulesByBucket>((acc, styleBucketName) => {
+    acc[styleBucketName] = [];
+
+    return acc;
+  }, {}) as Required<CSSRulesByBucket>;
+  const elements = compile(css);
+  const unrelatedElements: ReturnType<typeof compile> = [];
+
+  let cssBucketName: StyleBucketName | null = null;
+  let cssMeta: Record<string, unknown> | null = null;
+
+  for (const element of elements) {
+    if (element.type === COMMENT) {
+      if (element.value.indexOf('/** @griffel:css-start') === 0) {
+        cssBucketName = element.value.charAt(24) as StyleBucketName;
+        cssMeta = JSON.parse(element.value.slice(27, -4));
+
+        continue;
+      }
+
+      if (element.value.indexOf('/** @griffel:css-end') === 0) {
+        cssBucketName = null;
+        cssMeta = null;
+
+        continue;
+      }
+    }
+
+    if (cssBucketName) {
+      const cssRule = serialize([element], stringify);
+      const bucketEntry: CSSBucketEntry = cssMeta ? [cssRule, cssMeta!] : cssRule;
+
+      cssRulesByBucket[cssBucketName].push(bucketEntry);
+      continue;
+    }
+
+    unrelatedElements.push(element);
+  }
+
+  return { cssRulesByBucket, remainingCSS: serialize(unrelatedElements, stringify) };
+}
diff --git a/packages/webpack-plugin/src/utils/sortCSSRules.mts b/packages/webpack-plugin/src/utils/sortCSSRules.mts
new file mode 100644
index 000000000..23f02e811
--- /dev/null
+++ b/packages/webpack-plugin/src/utils/sortCSSRules.mts
@@ -0,0 +1,51 @@
+import {
+  styleBucketOrdering,
+  normalizeCSSBucketEntry,
+  type GriffelRenderer,
+  type StyleBucketName,
+  type CSSRulesByBucket,
+} from '@griffel/core';
+
+// avoid repeatedly calling `indexOf` to determine order during new insertions
+const styleBucketOrderingMap = styleBucketOrdering.reduce((acc, cur, j) => {
+  acc[cur as StyleBucketName] = j;
+  return acc;
+}, {} as Record<StyleBucketName, number>);
+
+type RuleEntry = { styleBucketName: StyleBucketName; cssRule: string; priority: number; media: string };
+
+export function getUniqueRulesFromSets(setOfCSSRules: CSSRulesByBucket[]): RuleEntry[] {
+  const uniqueCSSRules = new Map<string, RuleEntry>();
+
+  for (const cssRulesByBucket of setOfCSSRules) {
+    for (const _styleBucketName in cssRulesByBucket) {
+      const styleBucketName = _styleBucketName as StyleBucketName;
+
+      for (const bucketEntry of cssRulesByBucket[styleBucketName]!) {
+        const [cssRule, meta] = normalizeCSSBucketEntry(bucketEntry);
+
+        const priority = (meta?.['p'] as number | undefined) ?? 0;
+        const media = (meta?.['m'] as string | undefined) ?? '';
+
+        uniqueCSSRules.set(cssRule, { styleBucketName: styleBucketName as StyleBucketName, cssRule, priority, media });
+      }
+    }
+  }
+
+  return Array.from(uniqueCSSRules.values());
+}
+
+export function sortCSSRules(
+  setOfCSSRules: CSSRulesByBucket[],
+  compareMediaQueries: GriffelRenderer['compareMediaQueries'],
+): string {
+  return getUniqueRulesFromSets(setOfCSSRules)
+    .sort((entryA, entryB) => entryA.priority - entryB.priority)
+    .sort(
+      (entryA, entryB) =>
+        styleBucketOrderingMap[entryA.styleBucketName] - styleBucketOrderingMap[entryB.styleBucketName],
+    )
+    .sort((entryA, entryB) => compareMediaQueries(entryA.media, entryB.media))
+    .map(entry => entry.cssRule)
+    .join('');
+}
diff --git a/packages/webpack-plugin/src/virtual-loader/griffel.css b/packages/webpack-plugin/src/virtual-loader/griffel.css
new file mode 100644
index 000000000..d87ad61a6
--- /dev/null
+++ b/packages/webpack-plugin/src/virtual-loader/griffel.css
@@ -0,0 +1 @@
+/** A fake CSS file, used for Rspack compat */
diff --git a/packages/webpack-plugin/src/virtual-loader/index.cjs b/packages/webpack-plugin/src/virtual-loader/index.cjs
new file mode 100644
index 000000000..7850eeb13
--- /dev/null
+++ b/packages/webpack-plugin/src/virtual-loader/index.cjs
@@ -0,0 +1,20 @@
+const { URLSearchParams } = require('url');
+
+const GriffelCssLoaderContextKey = Symbol.for(`GriffelExtractPlugin/GriffelCssLoaderContextKey`);
+
+/**
+ * @this {import("../src/constants").SupplementedLoaderContext}
+ * @return {String}
+ */
+function virtualLoader() {
+  if (this.webpack) {
+    return this[GriffelCssLoaderContextKey]?.getExtractedCss() ?? '';
+  }
+
+  const query = new URLSearchParams(this.resourceQuery);
+  const style = query.get('style');
+
+  return style ?? '';
+}
+
+module.exports = virtualLoader;
diff --git a/packages/webpack-plugin/src/webpackLoader.mts b/packages/webpack-plugin/src/webpackLoader.mts
new file mode 100644
index 000000000..9ce13fe3a
--- /dev/null
+++ b/packages/webpack-plugin/src/webpackLoader.mts
@@ -0,0 +1,136 @@
+import { EvalCache, Module, transformSync, type TransformOptions, type TransformResult } from '@griffel/transform';
+import type * as webpack from 'webpack';
+import * as path from 'node:path';
+
+import { GriffelCssLoaderContextKey, type SupplementedLoaderContext } from './constants.mjs';
+import { generateCSSRules } from './utils/generateCSSRules.mjs';
+
+export type WebpackLoaderOptions = Omit<TransformOptions, 'filename' | 'generateMetadata'>;
+
+type WebpackLoaderParams = Parameters<webpack.LoaderDefinitionFunction<WebpackLoaderOptions>>;
+
+const __dirname = path.dirname(new URL(import.meta.url).pathname);
+// TODO: do something better, define via exports?
+const virtualLoaderPath = path.resolve(__dirname, 'virtual-loader', 'index.cjs');
+const virtualCSSFilePath = path.resolve(__dirname, 'virtual-loader', 'griffel.css');
+
+function toURIComponent(rule: string): string {
+  return encodeURIComponent(rule).replace(/!/g, '%21');
+}
+
+function webpackLoader(
+  this: SupplementedLoaderContext<WebpackLoaderOptions>,
+  sourceCode: WebpackLoaderParams[0],
+  inputSourceMap: WebpackLoaderParams[1],
+) {
+  this.async();
+  // Loaders are cacheable by default, but in edge cases/bugs when caching does not work until it's specified:
+  // https://github.com/webpack/webpack/issues/14946
+  this.cacheable();
+
+  // Early return to handle cases when there is no Griffel usage in the file
+  if (sourceCode.indexOf('makeStyles') === -1 && sourceCode.indexOf('makeResetStyles') === -1) {
+    this.callback(null, sourceCode, inputSourceMap);
+    return;
+  }
+
+  const IS_RSPACK = !this.webpack;
+
+  // @ Rspack compat:
+  // We don't use the trick with loader context as assets are generated differently
+  if (!IS_RSPACK) {
+    if (!this[GriffelCssLoaderContextKey]) {
+      throw new Error('GriffelCSSExtractionPlugin is not configured, please check your webpack config');
+    }
+  }
+
+  const { classNameHashSalt, modules, evaluationRules, babelOptions } = this.getOptions();
+
+  this[GriffelCssLoaderContextKey]!.runWithTimer(() => {
+    // Clear require cache to allow re-evaluation of modules
+    EvalCache.clearForFile(this.resourcePath);
+
+    const originalResolveFilename = Module._resolveFilename;
+
+    let result: TransformResult | null = null;
+    let error: Error | null = null;
+
+    try {
+      // We are evaluating modules in Babel plugin to resolve expressions (function calls, imported constants, etc.) in
+      // makeStyles() calls, see evaluatePathsInVM.ts.
+      // Webpack's config can define own module resolution, Babel plugin should use Webpack's resolution to properly
+      // resolve paths.
+      Module._resolveFilename = (id: string, params: any) => {
+        const resolvedPath = this[GriffelCssLoaderContextKey]!.resolveModule(id, params);
+
+        this.addDependency(resolvedPath);
+
+        return resolvedPath;
+      };
+
+      result = transformSync(sourceCode, {
+        filename: this.resourcePath,
+        classNameHashSalt,
+        modules,
+        evaluationRules,
+        babelOptions,
+      });
+    } catch (err) {
+      error = err as Error;
+    } finally {
+      // Restore original behaviour
+      Module._resolveFilename = originalResolveFilename;
+    }
+
+    if (result) {
+      const { code, cssRulesByBucket, usedVMForEvaluation } = result;
+      const meta = {
+        filename: this.resourcePath,
+        step: 'transform' as const,
+        evaluationMode: usedVMForEvaluation ? ('vm' as const) : ('ast' as const),
+      };
+
+      if (cssRulesByBucket) {
+        const css = generateCSSRules(cssRulesByBucket);
+
+        if (css.length === 0) {
+          this.callback(null, code);
+
+          return { result: undefined, meta };
+        }
+
+        if (IS_RSPACK) {
+          const request = `griffel.css!=!${virtualLoaderPath}!${virtualCSSFilePath}?style=${toURIComponent(css)}`;
+          const stringifiedRequest = JSON.stringify(this.utils.contextify(this.context || this.rootContext, request));
+
+          this.callback(null, `${result.code}\n\nimport ${stringifiedRequest};`);
+          return { result: undefined, meta };
+        }
+
+        this[GriffelCssLoaderContextKey]!.registerExtractedCss(css);
+
+        const outputFileName = this.resourcePath.replace(/\.[^.]+$/, '.griffel.css');
+        const request = `${outputFileName}!=!${virtualLoaderPath}!${this.resourcePath}`;
+        const stringifiedRequest = JSON.stringify(this.utils.contextify(this.context || this.rootContext, request));
+
+        this.callback(null, `${result.code}\n\nimport ${stringifiedRequest};`);
+        return { result: undefined, meta };
+      }
+
+      this.callback(null, code);
+      return { result: undefined, meta };
+    }
+
+    this.callback(error);
+    return {
+      result: undefined,
+      meta: {
+        filename: this.resourcePath,
+        step: 'transform' as const,
+        evaluationMode: 'ast' as const,
+      },
+    };
+  });
+}
+
+export default webpackLoader;
\ No newline at end of file
diff --git a/packages/webpack-plugin/tsconfig.json b/packages/webpack-plugin/tsconfig.json
index 0e8e67d56..12c050aae 100644
--- a/packages/webpack-plugin/tsconfig.json
+++ b/packages/webpack-plugin/tsconfig.json
@@ -6,7 +6,10 @@
     "noImplicitOverride": true,
     "noPropertyAccessFromIndexSignature": true,
     "noImplicitReturns": true,
-    "noFallthroughCasesInSwitch": true
+    "noFallthroughCasesInSwitch": true,
+    "module": "NodeNext",
+    "moduleResolution": "NodeNext",
+    "target": "ES2022"
   },
   "files": [],
   "include": [],
diff --git a/packages/webpack-plugin/tsconfig.lib.json b/packages/webpack-plugin/tsconfig.lib.json
index c5e5275a7..ec2fdbbaa 100644
--- a/packages/webpack-plugin/tsconfig.lib.json
+++ b/packages/webpack-plugin/tsconfig.lib.json
@@ -3,7 +3,7 @@
   "compilerOptions": {
     "outDir": "../../dist/out-tsc",
     "declaration": true,
-    "types": ["node"]
+    "types": ["node", "environment"]
   },
   "include": ["src/**/*.ts", "src/**/*.mts"],
   "exclude": ["jest.config.ts", "src/**/*.spec.ts", "src/**/*.test.ts", "src/**/*.spec.tsx", "src/**/*.test.tsx"]
diff --git a/packages/webpack-plugin/vite.config.ts b/packages/webpack-plugin/vite.config.ts
index d49c919d4..c69647a68 100644
--- a/packages/webpack-plugin/vite.config.ts
+++ b/packages/webpack-plugin/vite.config.ts
@@ -27,7 +27,10 @@ export default defineConfig(() => ({
   build: {
     emptyOutDir: true,
     lib: {
-      entry: resolve(__dirname, 'src/index.mts'),
+      entry: {
+        'webpack-plugin': resolve(__dirname, 'src/index.mts'),
+        'webpack-loader': resolve(__dirname, 'src/webpackLoader.mts'),
+      },
       formats: ['es' as const],
       target: 'node20' as const,
     },
diff --git a/tsconfig.base.json b/tsconfig.base.json
index 59d85e320..7ac93e476 100644
--- a/tsconfig.base.json
+++ b/tsconfig.base.json
@@ -28,10 +28,12 @@
       "@griffel/tag-processor": ["packages/tag-processor/src/index.ts"],
       "@griffel/tag-processor/make-reset-styles": ["packages/tag-processor/src/MakeResetStylesProcessor.ts"],
       "@griffel/tag-processor/make-styles": ["packages/tag-processor/src/MakeStylesProcessor.ts"],
+      "@griffel/transform": ["packages/transform/src/index.mts"],
       "@griffel/update-shorthands": ["tools/update-shorthands/src/index.ts"],
       "@griffel/vite-plugin": ["packages/vite-plugin/src/index.ts"],
       "@griffel/webpack-extraction-plugin": ["packages/webpack-extraction-plugin/src/index.ts"],
-      "@griffel/webpack-loader": ["packages/webpack-loader/src/index.ts"]
+      "@griffel/webpack-loader": ["packages/webpack-loader/src/index.ts"],
+      "@griffel/webpack-plugin": ["packages/webpack-plugin/src/index.mts"]
     },
     "typeRoots": ["node_modules/@types", "./typings"]
   },
diff --git a/yarn.lock b/yarn.lock
index 124fe557d..44ea47d08 100644
--- a/yarn.lock
+++ b/yarn.lock
@@ -3260,17 +3260,17 @@ __metadata:
   languageName: node
   linkType: hard
 
-"@emnapi/core@npm:^1.1.0, @emnapi/core@npm:^1.4.3, @emnapi/core@npm:^1.5.0":
-  version: 1.5.0
-  resolution: "@emnapi/core@npm:1.5.0"
+"@emnapi/core@npm:^1.1.0, @emnapi/core@npm:^1.4.3, @emnapi/core@npm:^1.5.0, @emnapi/core@npm:^1.7.1":
+  version: 1.8.1
+  resolution: "@emnapi/core@npm:1.8.1"
   dependencies:
     "@emnapi/wasi-threads": "npm:1.1.0"
     tslib: "npm:^2.4.0"
-  checksum: 10/b500a69df001580731b0d355298b58832d44ab176937c0db7d10073a396f7a801ebcca10581f125a1cd88af4e6ecd6fbb04b78629cc703a424218b3a36d7bf50
+  checksum: 10/904ea60c91fc7d8aeb4a8f2c433b8cfb47c50618f2b6f37429fc5093c857c6381c60628a5cfbc3a7b0d75b0a288f21d4ed2d4533e82f92c043801ef255fd6a5c
   languageName: node
   linkType: hard
 
-"@emnapi/runtime@npm:^1.1.0, @emnapi/runtime@npm:^1.4.3, @emnapi/runtime@npm:^1.5.0, @emnapi/runtime@npm:^1.7.0":
+"@emnapi/runtime@npm:^1.1.0, @emnapi/runtime@npm:^1.4.3, @emnapi/runtime@npm:^1.5.0, @emnapi/runtime@npm:^1.7.0, @emnapi/runtime@npm:^1.7.1":
   version: 1.8.1
   resolution: "@emnapi/runtime@npm:1.8.1"
   dependencies:
@@ -4948,7 +4948,7 @@ __metadata:
   languageName: node
   linkType: hard
 
-"@napi-rs/wasm-runtime@npm:1.0.7, @napi-rs/wasm-runtime@npm:^1.0.5":
+"@napi-rs/wasm-runtime@npm:1.0.7":
   version: 1.0.7
   resolution: "@napi-rs/wasm-runtime@npm:1.0.7"
   dependencies:
@@ -4970,6 +4970,17 @@ __metadata:
   languageName: node
   linkType: hard
 
+"@napi-rs/wasm-runtime@npm:^1.0.5, @napi-rs/wasm-runtime@npm:^1.1.1":
+  version: 1.1.1
+  resolution: "@napi-rs/wasm-runtime@npm:1.1.1"
+  dependencies:
+    "@emnapi/core": "npm:^1.7.1"
+    "@emnapi/runtime": "npm:^1.7.1"
+    "@tybys/wasm-util": "npm:^0.10.1"
+  checksum: 10/080e7f2aefb84e09884d21c650a2cbafdf25bfd2634693791b27e36eec0ddaa3c1656a943f8c913ac75879a0b04e68f8a827897ee655ab54a93169accf05b194
+  languageName: node
+  linkType: hard
+
 "@next/env@npm:15.5.10":
   version: 15.5.10
   resolution: "@next/env@npm:15.5.10"
@@ -5656,6 +5667,148 @@ __metadata:
   languageName: node
   linkType: hard
 
+"@oxc-resolver/binding-android-arm-eabi@npm:11.19.1":
+  version: 11.19.1
+  resolution: "@oxc-resolver/binding-android-arm-eabi@npm:11.19.1"
+  conditions: os=android & cpu=arm
+  languageName: node
+  linkType: hard
+
+"@oxc-resolver/binding-android-arm64@npm:11.19.1":
+  version: 11.19.1
+  resolution: "@oxc-resolver/binding-android-arm64@npm:11.19.1"
+  conditions: os=android & cpu=arm64
+  languageName: node
+  linkType: hard
+
+"@oxc-resolver/binding-darwin-arm64@npm:11.19.1":
+  version: 11.19.1
+  resolution: "@oxc-resolver/binding-darwin-arm64@npm:11.19.1"
+  conditions: os=darwin & cpu=arm64
+  languageName: node
+  linkType: hard
+
+"@oxc-resolver/binding-darwin-x64@npm:11.19.1":
+  version: 11.19.1
+  resolution: "@oxc-resolver/binding-darwin-x64@npm:11.19.1"
+  conditions: os=darwin & cpu=x64
+  languageName: node
+  linkType: hard
+
+"@oxc-resolver/binding-freebsd-x64@npm:11.19.1":
+  version: 11.19.1
+  resolution: "@oxc-resolver/binding-freebsd-x64@npm:11.19.1"
+  conditions: os=freebsd & cpu=x64
+  languageName: node
+  linkType: hard
+
+"@oxc-resolver/binding-linux-arm-gnueabihf@npm:11.19.1":
+  version: 11.19.1
+  resolution: "@oxc-resolver/binding-linux-arm-gnueabihf@npm:11.19.1"
+  conditions: os=linux & cpu=arm
+  languageName: node
+  linkType: hard
+
+"@oxc-resolver/binding-linux-arm-musleabihf@npm:11.19.1":
+  version: 11.19.1
+  resolution: "@oxc-resolver/binding-linux-arm-musleabihf@npm:11.19.1"
+  conditions: os=linux & cpu=arm
+  languageName: node
+  linkType: hard
+
+"@oxc-resolver/binding-linux-arm64-gnu@npm:11.19.1":
+  version: 11.19.1
+  resolution: "@oxc-resolver/binding-linux-arm64-gnu@npm:11.19.1"
+  conditions: os=linux & cpu=arm64 & libc=glibc
+  languageName: node
+  linkType: hard
+
+"@oxc-resolver/binding-linux-arm64-musl@npm:11.19.1":
+  version: 11.19.1
+  resolution: "@oxc-resolver/binding-linux-arm64-musl@npm:11.19.1"
+  conditions: os=linux & cpu=arm64 & libc=musl
+  languageName: node
+  linkType: hard
+
+"@oxc-resolver/binding-linux-ppc64-gnu@npm:11.19.1":
+  version: 11.19.1
+  resolution: "@oxc-resolver/binding-linux-ppc64-gnu@npm:11.19.1"
+  conditions: os=linux & cpu=ppc64 & libc=glibc
+  languageName: node
+  linkType: hard
+
+"@oxc-resolver/binding-linux-riscv64-gnu@npm:11.19.1":
+  version: 11.19.1
+  resolution: "@oxc-resolver/binding-linux-riscv64-gnu@npm:11.19.1"
+  conditions: os=linux & cpu=riscv64 & libc=glibc
+  languageName: node
+  linkType: hard
+
+"@oxc-resolver/binding-linux-riscv64-musl@npm:11.19.1":
+  version: 11.19.1
+  resolution: "@oxc-resolver/binding-linux-riscv64-musl@npm:11.19.1"
+  conditions: os=linux & cpu=riscv64 & libc=musl
+  languageName: node
+  linkType: hard
+
+"@oxc-resolver/binding-linux-s390x-gnu@npm:11.19.1":
+  version: 11.19.1
+  resolution: "@oxc-resolver/binding-linux-s390x-gnu@npm:11.19.1"
+  conditions: os=linux & cpu=s390x & libc=glibc
+  languageName: node
+  linkType: hard
+
+"@oxc-resolver/binding-linux-x64-gnu@npm:11.19.1":
+  version: 11.19.1
+  resolution: "@oxc-resolver/binding-linux-x64-gnu@npm:11.19.1"
+  conditions: os=linux & cpu=x64 & libc=glibc
+  languageName: node
+  linkType: hard
+
+"@oxc-resolver/binding-linux-x64-musl@npm:11.19.1":
+  version: 11.19.1
+  resolution: "@oxc-resolver/binding-linux-x64-musl@npm:11.19.1"
+  conditions: os=linux & cpu=x64 & libc=musl
+  languageName: node
+  linkType: hard
+
+"@oxc-resolver/binding-openharmony-arm64@npm:11.19.1":
+  version: 11.19.1
+  resolution: "@oxc-resolver/binding-openharmony-arm64@npm:11.19.1"
+  conditions: os=openharmony & cpu=arm64
+  languageName: node
+  linkType: hard
+
+"@oxc-resolver/binding-wasm32-wasi@npm:11.19.1":
+  version: 11.19.1
+  resolution: "@oxc-resolver/binding-wasm32-wasi@npm:11.19.1"
+  dependencies:
+    "@napi-rs/wasm-runtime": "npm:^1.1.1"
+  conditions: cpu=wasm32
+  languageName: node
+  linkType: hard
+
+"@oxc-resolver/binding-win32-arm64-msvc@npm:11.19.1":
+  version: 11.19.1
+  resolution: "@oxc-resolver/binding-win32-arm64-msvc@npm:11.19.1"
+  conditions: os=win32 & cpu=arm64
+  languageName: node
+  linkType: hard
+
+"@oxc-resolver/binding-win32-ia32-msvc@npm:11.19.1":
+  version: 11.19.1
+  resolution: "@oxc-resolver/binding-win32-ia32-msvc@npm:11.19.1"
+  conditions: os=win32 & cpu=ia32
+  languageName: node
+  linkType: hard
+
+"@oxc-resolver/binding-win32-x64-msvc@npm:11.19.1":
+  version: 11.19.1
+  resolution: "@oxc-resolver/binding-win32-x64-msvc@npm:11.19.1"
+  conditions: os=win32 & cpu=x64
+  languageName: node
+  linkType: hard
+
 "@parcel/watcher-android-arm64@npm:2.5.1":
   version: 2.5.1
   resolution: "@parcel/watcher-android-arm64@npm:2.5.1"
@@ -15516,6 +15669,7 @@ __metadata:
     next: "npm:15.5.10"
     nx: "npm:22.3.3"
     oxc-parser: "npm:^0.90.0"
+    oxc-resolver: "npm:^11.8.2"
     oxc-walker: "npm:^0.5.2"
     postcss: "npm:8.4.47"
     prettier: "npm:2.8.2"
@@ -21262,6 +21416,75 @@ __metadata:
   languageName: node
   linkType: hard
 
+"oxc-resolver@npm:^11.8.2":
+  version: 11.19.1
+  resolution: "oxc-resolver@npm:11.19.1"
+  dependencies:
+    "@oxc-resolver/binding-android-arm-eabi": "npm:11.19.1"
+    "@oxc-resolver/binding-android-arm64": "npm:11.19.1"
+    "@oxc-resolver/binding-darwin-arm64": "npm:11.19.1"
+    "@oxc-resolver/binding-darwin-x64": "npm:11.19.1"
+    "@oxc-resolver/binding-freebsd-x64": "npm:11.19.1"
+    "@oxc-resolver/binding-linux-arm-gnueabihf": "npm:11.19.1"
+    "@oxc-resolver/binding-linux-arm-musleabihf": "npm:11.19.1"
+    "@oxc-resolver/binding-linux-arm64-gnu": "npm:11.19.1"
+    "@oxc-resolver/binding-linux-arm64-musl": "npm:11.19.1"
+    "@oxc-resolver/binding-linux-ppc64-gnu": "npm:11.19.1"
+    "@oxc-resolver/binding-linux-riscv64-gnu": "npm:11.19.1"
+    "@oxc-resolver/binding-linux-riscv64-musl": "npm:11.19.1"
+    "@oxc-resolver/binding-linux-s390x-gnu": "npm:11.19.1"
+    "@oxc-resolver/binding-linux-x64-gnu": "npm:11.19.1"
+    "@oxc-resolver/binding-linux-x64-musl": "npm:11.19.1"
+    "@oxc-resolver/binding-openharmony-arm64": "npm:11.19.1"
+    "@oxc-resolver/binding-wasm32-wasi": "npm:11.19.1"
+    "@oxc-resolver/binding-win32-arm64-msvc": "npm:11.19.1"
+    "@oxc-resolver/binding-win32-ia32-msvc": "npm:11.19.1"
+    "@oxc-resolver/binding-win32-x64-msvc": "npm:11.19.1"
+  dependenciesMeta:
+    "@oxc-resolver/binding-android-arm-eabi":
+      optional: true
+    "@oxc-resolver/binding-android-arm64":
+      optional: true
+    "@oxc-resolver/binding-darwin-arm64":
+      optional: true
+    "@oxc-resolver/binding-darwin-x64":
+      optional: true
+    "@oxc-resolver/binding-freebsd-x64":
+      optional: true
+    "@oxc-resolver/binding-linux-arm-gnueabihf":
+      optional: true
+    "@oxc-resolver/binding-linux-arm-musleabihf":
+      optional: true
+    "@oxc-resolver/binding-linux-arm64-gnu":
+      optional: true
+    "@oxc-resolver/binding-linux-arm64-musl":
+      optional: true
+    "@oxc-resolver/binding-linux-ppc64-gnu":
+      optional: true
+    "@oxc-resolver/binding-linux-riscv64-gnu":
+      optional: true
+    "@oxc-resolver/binding-linux-riscv64-musl":
+      optional: true
+    "@oxc-resolver/binding-linux-s390x-gnu":
+      optional: true
+    "@oxc-resolver/binding-linux-x64-gnu":
+      optional: true
+    "@oxc-resolver/binding-linux-x64-musl":
+      optional: true
+    "@oxc-resolver/binding-openharmony-arm64":
+      optional: true
+    "@oxc-resolver/binding-wasm32-wasi":
+      optional: true
+    "@oxc-resolver/binding-win32-arm64-msvc":
+      optional: true
+    "@oxc-resolver/binding-win32-ia32-msvc":
+      optional: true
+    "@oxc-resolver/binding-win32-x64-msvc":
+      optional: true
+  checksum: 10/a6c8fdb2ef4bf9bb84f28e58685457de427d31f74373c0fbd6d1106010cab33027fa3b4336b1b86d0df0a089cd73a6060b730b1b24974d56c59f6fa29c559f9d
+  languageName: node
+  linkType: hard
+
 "oxc-walker@npm:^0.5.2":
   version: 0.5.2
   resolution: "oxc-walker@npm:0.5.2"