@plaudit/webpack-extensions 3.4.1 → 3.5.1

package/CHANGELOG.md

@@ -5,6 +5,15 @@ All notable changes to this project will be documented in this file.
 The format is based on [Keep a Changelog](https://keepachangelog.com/en/1.1.0/),
 and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0.html).
 
+## [3.5.1] - 2026-03-30
+### Fixed
+- The paths in package.json that were broken after switching to dist
+
+## [3.5.0] - 2026-03-30
+### Added
+- Support for explicitly setting the handle for block assets
+  - This comes from version `2.88.0`
+
 ## [3.4.1] - 2026-03-17
 ### Changed
 - The `blockdir-loader.php` generation logic to use static wp_register_* calls like `plain-entrypoints-loader.php`
@@ -71,6 +80,14 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
 - Legacy PostCSS features that have been integrated into modern CSS
 - `@extends` support
 
+## [2.88.1] - 2026-03-30
+### Fixed
+- The paths in package.json that were broken after switching to dist
+
+## [2.88.0] - 2026-03-30
+### Added
+- Support for explicitly setting the handle for block assets
+
 ## [2.87.1] - 2026-03-17
 ### Changed
 - The `blockdir-loader.php` generation logic to use static wp_register_* calls like `plain-entrypoints-loader.php`

package/USER-GUIDE.md

@@ -400,7 +400,8 @@ This section covers the shared options for entrypoints. See the [Entrypoint Type
 - These are URL-style queries added to the end of entrypoint *source* paths and are used to set entrypoint-specific properties in Plain and Block contexts.
   - If you find yourself using these, consider switching to [Location-Encoding Filenames](#location-encoding-filenames)
   - At present, this is only being used to configure inlining, but expansion to other systems is being considered
-  - The available options are: `strategy`, `inline`, `in_footer`, `fetchpriority`, and `position`
+  - The available options are: `strategy`, `inline`, `in_footer`, `fetchpriority`, `position`, and `handle`
+    - Handle is only available on blocks – declare the handle using the [Locations object](#the-locations-object)
 
 ### Boolean-form
 - This is only available if `outputDir` has been set
@@ -520,7 +521,7 @@ Filenames **must** follow the pattern: `{kebab-case-block-name}-{type}.{ext}`
   - This is only available in extensions v2 and up
 
 #### Notes
-- In order to have a directory be treated as `extensions`, the config **must** include `directoryLayout: 'extensions'`
+- To have a directory be treated as `extensions`, the config **must** include `directoryLayout: 'extensions'`
 - Extensions **should** be created with `pnpm @plaudit/scaffold create extension`
 
 #### Per-Entrypoint Options

package/{build → dist}/plugins/EnhancedBlockJSONPlugin.js

@@ -1,21 +1,18 @@
 "use strict";
-var __importDefault = (this && this.__importDefault) || function (mod) {
-    return (mod && mod.__esModule) ? mod : { "default": mod };
-};
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.EnhancedBlockJSONPlugin = void 0;
-const node_crypto_1 = __importDefault(require("node:crypto"));
+const node_crypto_1 = require("node:crypto");
 const promises_1 = require("node:fs/promises");
-const node_fs_1 = __importDefault(require("node:fs"));
-const node_path_1 = __importDefault(require("node:path"));
-const AbstractBiPhasicGroupAndEntryPlugin_1 = require("./AbstractBiPhasicGroupAndEntryPlugin");
-const UnifiedLoaderGenerator_1 = require("./UnifiedLoaderGenerator");
+const node_fs_1 = require("node:fs");
+const node_path_1 = require("node:path");
 const php_writer_1 = require("@plaudit/php-writer");
 const expressions_1 = require("@plaudit/php-writer/expressions");
+const webpack_1 = require("webpack");
+const AbstractBiPhasicGroupAndEntryPlugin_1 = require("./AbstractBiPhasicGroupAndEntryPlugin");
+const UnifiedLoaderGenerator_1 = require("./UnifiedLoaderGenerator");
 const shared_1 = require("../shared");
 const path_query_and_related_helpers_1 = require("../utils/path-query-and-related-helpers");
 const pseduo_semaphore_1 = require("../utils/pseduo-semaphore");
-const webpack_1 = require("webpack");
 class EnhancedBlockJSONPlugin extends AbstractBiPhasicGroupAndEntryPlugin_1.AbstractBiPhasicGroupAndEntryPlugin {
     dest;
     webpackRemoveEmptyScriptsPlugin;
@@ -30,7 +27,7 @@ class EnhancedBlockJSONPlugin extends AbstractBiPhasicGroupAndEntryPlugin_1.Abst
         const blockJsonOriginToOutputMapping = {};
         const relevantEntrypoints = this.getRelevantEntrypoints(compilation).toArray();
         for (const { entrypoint, metadata, srcPath } of relevantEntrypoints) {
-            if (node_path_1.default.basename(srcPath).toLowerCase() !== "block.json" || !('purpose' in metadata) || metadata.purpose !== "block-json-inclusion-assurance") {
+            if ((0, node_path_1.basename)(srcPath).toLowerCase() !== "block.json" || !('purpose' in metadata) || metadata.purpose !== "block-json-inclusion-assurance") {
                 continue;
             }
             const asset = [...compilation.chunkGraph.getChunkEntryModulesIterable(entrypoint.getEntrypointChunk())][0]?.originalSource();
@@ -48,11 +45,11 @@ class EnhancedBlockJSONPlugin extends AbstractBiPhasicGroupAndEntryPlugin_1.Abst
             }
         }
         for (const { entrypoint, metadata, srcPath } of relevantEntrypoints) {
-            if (node_path_1.default.basename(srcPath).toLowerCase() === "block.json" || 'purpose' in metadata) {
+            if ((0, node_path_1.basename)(srcPath).toLowerCase() === "block.json" || 'purpose' in metadata) {
                 continue;
             }
             const entrypointChunk = entrypoint.getEntrypointChunk();
-            const epBlockJson = entrypointChunk.auxiliaryFiles.values().find(auxFile => node_path_1.default.basename(auxFile) === "block.json")
+            const epBlockJson = entrypointChunk.auxiliaryFiles.values().find(auxFile => (0, node_path_1.basename)(auxFile) === "block.json")
                 ?? blockJsonOriginToOutputMapping[metadata.blockJsonOrigin];
             if (epBlockJson) {
                 const assetData = parsedAssetJsonProvider(entrypoint, metadata)?.assetData;
@@ -65,7 +62,7 @@ class EnhancedBlockJSONPlugin extends AbstractBiPhasicGroupAndEntryPlugin_1.Abst
                     .map(file => [file, (0, shared_1.scriptOrStyleTest)(file, shared_1.scriptExtension)])
                     .filter((item) => item[1] !== '')
                     .map(([file, assetType]) => {
-                    const enqueuingFlags = (0, path_query_and_related_helpers_1.mergeTwoScriptEnqueuingControlFlagSets)(file, metadata.enqueuingFlags, this.dest.enqueuingFlags);
+                    const enqueuingFlags = (0, path_query_and_related_helpers_1.mergeTwoEnqueuingControlFlagSets)(file, metadata.enqueuingFlags, this.dest.enqueuingFlags);
                     const { scriptArgsObject, inlinedAsset } = (0, path_query_and_related_helpers_1.convertEnqueuingControlFlagsToScriptArgsObject)(compilation, file, enqueuingFlags);
                     const wasOriginallyAStyleField = (0, shared_1.isStyleField)(metadata.entrypointField);
                     const outputPath = this.stripOffBlocksDestPrefix(file);
@@ -88,10 +85,10 @@ class EnhancedBlockJSONPlugin extends AbstractBiPhasicGroupAndEntryPlugin_1.Abst
         }
         EnhancedBlockJSONPlugin.semaphore.resolve(this.id, {
             collatableWorkableBlockInfo: applicableBlockJsonFiles, blocksDest: this.dest.destination,
-            emittingWpmlXml: compilation.getAsset(node_path_1.default.join(this.dest.destination, "wpml-config.xml")) !== undefined
+            emittingWpmlXml: compilation.getAsset((0, node_path_1.join)(this.dest.destination, "wpml-config.xml")) !== undefined
         });
         const generateLoader = (writer) => {
-            writer.require(node_path_1.default.join(this.dest.destination, "blockdir-loader.php"), { dirRelative: true, once: true });
+            writer.require((0, node_path_1.join)(this.dest.destination, "blockdir-loader.php"), { dirRelative: true, once: true });
         };
         let action;
         const lazyLoader = this.dest.lazyLoader;
@@ -167,10 +164,10 @@ class EnhancedBlockJSONPlugin extends AbstractBiPhasicGroupAndEntryPlugin_1.Abst
                     (0, shared_1.appendAddInlineAssetCall)(compilation, writer, ...inlinableStyle);
                 }
             }, { accountForAlreadyDoing: this.config.includePostInitFallback });
-            (0, shared_1.emitPHPWriterAsAsset)(writer, compilation, node_path_1.default.join(this.dest.destination, "blockdir-loader.php"));
+            (0, shared_1.emitPHPWriterAsAsset)(writer, compilation, (0, node_path_1.join)(this.dest.destination, "blockdir-loader.php"));
         }
         else {
-            compilation.emitAsset(node_path_1.default.join(this.dest.destination, "blockdir.config.php"), new webpack_1.sources.RawSource((0, shared_1.makeEmittableConfigPHP)(blockDirConfig, true)));
+            compilation.emitAsset((0, node_path_1.join)(this.dest.destination, "blockdir.config.php"), new webpack_1.sources.RawSource((0, shared_1.makeEmittableConfigPHP)(blockDirConfig, true)));
         }
     }
     callRegisterFunction(type, writer, baseUriVar, handles) {
@@ -192,8 +189,8 @@ class EnhancedBlockJSONPlugin extends AbstractBiPhasicGroupAndEntryPlugin_1.Abst
                 compilation.errors.push((0, shared_1.newWebpackErrorForFile)(`${blockJsonAssetName} does not have recorded text`, blockJsonAssetName));
                 continue;
             }
-            const sourceDir = node_path_1.default.dirname(blockJsonSourcePath);
-            const outputDir = node_path_1.default.join(compilation.compiler.outputPath, node_path_1.default.dirname(blockJsonAssetName));
+            const sourceDir = (0, node_path_1.dirname)(blockJsonSourcePath);
+            const outputDir = (0, node_path_1.join)(compilation.compiler.outputPath, (0, node_path_1.dirname)(blockJsonAssetName));
             const blockJson = JSON.parse(blockJsonText);
             const pathsNeedRemapping = !this.config.standaloneBlocks && blockJson["plaudit"] !== "simple";
             EnhancedBlockJSONPlugin.remapReferencedPHPFilesOnKey(blockJson, "setup", pathsNeedRemapping, sourceDir, outputDir, compilation, true);
@@ -207,11 +204,11 @@ class EnhancedBlockJSONPlugin extends AbstractBiPhasicGroupAndEntryPlugin_1.Abst
                 blockJson["version"] = hashForVersion;
             }
             EnhancedBlockJSONPlugin.normalizeRenderTemplate(blockJson, pathsNeedRemapping, sourceDir, outputDir, compilation);
-            const blockDirName = node_path_1.default.dirname(node_path_1.default.relative(this.dest.destination, blockJsonAssetName));
+            const blockDirName = (0, node_path_1.dirname)((0, node_path_1.relative)(this.dest.destination, blockJsonAssetName));
             blockData[blockDirName] = EnhancedBlockJSONPlugin
                 .doFileOrHandleReplacements(compilation, Object.fromEntries(Object.entries(blockJson).filter(([k]) => k !== '$schema')), workableBlockEntrypointsInfo, epi => epi.handle);
-            compilation[blockJsonAssetName in compilation.assets ? 'updateAsset' : 'emitAsset'](blockJsonAssetName, new webpack_1.sources.RawSource(JSON.stringify(EnhancedBlockJSONPlugin
-                .doFileOrHandleReplacements(compilation, blockJson, workableBlockEntrypointsInfo, epi => "file:./" + node_path_1.default.relative(blockDirName, epi.outputPath)), undefined, "  ")));
+            const emittableBlockJson = EnhancedBlockJSONPlugin.doFileOrHandleReplacements(compilation, blockJson, workableBlockEntrypointsInfo, epi => "file:./" + (0, node_path_1.relative)(blockDirName, epi.outputPath));
+            compilation[blockJsonAssetName in compilation.assets ? 'updateAsset' : 'emitAsset'](blockJsonAssetName, new webpack_1.sources.RawSource(JSON.stringify(emittableBlockJson, undefined, "  ")));
         }
         return {
             __metadata: {
@@ -297,13 +294,13 @@ class EnhancedBlockJSONPlugin extends AbstractBiPhasicGroupAndEntryPlugin_1.Abst
         return this.dest.destination && file.startsWith(this.dest.destination + "/") ? file.substring(this.dest.destination.length + 1 /* we also need to drop the "/" */) : file;
     }
     static hashThingForAsset(thing) {
-        return node_crypto_1.default.createHash('md5').update(thing).digest("hex").substring(0, 20).toLowerCase();
+        return (0, node_crypto_1.createHash)('md5').update(thing).digest("hex").substring(0, 20).toLowerCase();
     }
     static stripFilePrefix(file) {
         return file.startsWith("file:./") ? file.substring(7) : file;
     }
     static findCommonAncestor(...paths) {
-        return paths.map(p => node_path_1.default.normalize(p).split(node_path_1.default.sep)).reduce((prior, current) => {
+        return paths.map(p => (0, node_path_1.normalize)(p).split(node_path_1.sep)).reduce((prior, current) => {
             for (let i = 0, limit = Math.min(prior.length, current.length); i < limit; i++) {
                 if (prior[i] !== current[i]) {
                     return prior.slice(0, i);
@@ -314,9 +311,7 @@ class EnhancedBlockJSONPlugin extends AbstractBiPhasicGroupAndEntryPlugin_1.Abst
     }
     static findRelativeRouteBetween(path1, path2) {
         const commonAncestor = EnhancedBlockJSONPlugin.findCommonAncestor(path1, path2);
-        const route = Array(path1.split(node_path_1.default.sep).length - commonAncestor.length).fill("..");
-        route.push(node_path_1.default.relative(commonAncestor.join(node_path_1.default.sep), path2));
-        return route.join(node_path_1.default.sep);
+        return (".." + node_path_1.sep).repeat(path1.split(node_path_1.sep).length - commonAncestor.length) + (0, node_path_1.relative)(commonAncestor.join(node_path_1.sep), path2);
     }
     static remapReferencedPHPFilesOnKey(blockJson, key, pathsNeedRemapping, sourceDir, outputDir, compilation, inPlaudit) {
         const rawValue = (inPlaudit ? blockJson["plaudit"] : blockJson)?.[key];
@@ -332,7 +327,7 @@ class EnhancedBlockJSONPlugin extends AbstractBiPhasicGroupAndEntryPlugin_1.Abst
             }
             else {
                 if (fileReferences.length !== 0) {
-                    compilation.warnings.push((0, shared_1.newWebpackErrorForFile)(`Encountered a block with a mixture of file-reference and non-file-reference elements in the "${inPlaudit ? 'plaudit.' : ''}${key}" property`, node_path_1.default.join(sourceDir, 'block.json')));
+                    compilation.warnings.push((0, shared_1.newWebpackErrorForFile)(`Encountered a block with a mixture of file-reference and non-file-reference elements in the "${inPlaudit ? 'plaudit.' : ''}${key}" property`, (0, node_path_1.join)(sourceDir, 'block.json')));
                     rawFiles = fileReferences;
                 }
                 else {
@@ -349,11 +344,11 @@ class EnhancedBlockJSONPlugin extends AbstractBiPhasicGroupAndEntryPlugin_1.Abst
         }
         const mappedFiles = pathsNeedRemapping
             ? rawFiles
-                .map(p => node_path_1.default.normalize(node_path_1.default.join(sourceDir, EnhancedBlockJSONPlugin.stripFilePrefix(p))))
-                .filter(p => node_fs_1.default.existsSync(p))
+                .map(p => (0, node_path_1.normalize)((0, node_path_1.join)(sourceDir, EnhancedBlockJSONPlugin.stripFilePrefix(p))))
+                .filter(node_fs_1.existsSync)
                 .map(p => `file:./${EnhancedBlockJSONPlugin.findRelativeRouteBetween(outputDir, p)}`)
             : rawFiles
-                .filter(p => node_fs_1.default.existsSync(node_path_1.default.normalize(node_path_1.default.join(sourceDir, EnhancedBlockJSONPlugin.stripFilePrefix(p)))));
+                .filter(p => (0, node_fs_1.existsSync)((0, node_path_1.normalize)((0, node_path_1.join)(sourceDir, EnhancedBlockJSONPlugin.stripFilePrefix(p)))));
         if (mappedFiles.length === 0) {
             if (deleteOnEmpty && rawValue !== undefined) {
                 delete (inPlaudit ? blockJson["plaudit"] : blockJson)[key];
@@ -389,11 +384,11 @@ class EnhancedBlockJSONPlugin extends AbstractBiPhasicGroupAndEntryPlugin_1.Abst
             : [`${blockName.substring(blockName.indexOf('/') + 1)}.php`, "template.php", "template.twig"]);
         const renderTemplate = pathsNeedRemapping
             ? rawRenderTemplate
-                .map(p => node_path_1.default.normalize(node_path_1.default.join(sourceDir, EnhancedBlockJSONPlugin.stripFilePrefix(p))))
-                .filter(p => node_fs_1.default.existsSync(p))
+                .map(p => (0, node_path_1.normalize)((0, node_path_1.join)(sourceDir, EnhancedBlockJSONPlugin.stripFilePrefix(p))))
+                .filter(node_fs_1.existsSync)
                 .map(p => `file:./${EnhancedBlockJSONPlugin.findRelativeRouteBetween(outputDir, p)}`)
             : rawRenderTemplate
-                .filter(p => node_fs_1.default.existsSync(node_path_1.default.normalize(node_path_1.default.join(sourceDir, EnhancedBlockJSONPlugin.stripFilePrefix(p)))));
+                .filter(p => (0, node_fs_1.existsSync)((0, node_path_1.normalize)((0, node_path_1.join)(sourceDir, EnhancedBlockJSONPlugin.stripFilePrefix(p)))));
         if (renderTemplate.length === 0) {
             delete blockJson["render_template"];
             delete blockJson["render"];
@@ -412,7 +407,7 @@ class EnhancedBlockJSONPlugin extends AbstractBiPhasicGroupAndEntryPlugin_1.Abst
             }
             delete blockJson[invalidTemplateLocation];
             if (renderTemplate.length > 1) {
-                compilation.warnings.push((0, shared_1.newWebpackErrorForFile)("Encountered a block with multiple possible render files", node_path_1.default.join(sourceDir, 'block.json')));
+                compilation.warnings.push((0, shared_1.newWebpackErrorForFile)("Encountered a block with multiple possible render files", (0, node_path_1.join)(sourceDir, 'block.json')));
                 blockJson[validTemplateLocation] = renderTemplate.find(p => p.endsWith(".php")) ?? renderTemplate[0];
             }
             else {
@@ -459,7 +454,7 @@ class EnhancedBlockJSONPlugin extends AbstractBiPhasicGroupAndEntryPlugin_1.Abst
         compilation.hooks.processAssets.tapPromise({ name: `${this.constructor.name}_CompileLoader`, stage: webpack_1.Compilation.PROCESS_ASSETS_STAGE_OPTIMIZE_TRANSFER }, async () => {
             const relevantEntrypoints = this.getRelevantEntrypoints(compilation).toArray();
             for (const { entrypoint, metadata, srcPath } of relevantEntrypoints) {
-                if (node_path_1.default.basename(srcPath).toLowerCase() !== "block.json" || !('purpose' in metadata) || metadata.purpose !== "block-json-inclusion-assurance") {
+                if ((0, node_path_1.basename)(srcPath).toLowerCase() !== "block.json" || !('purpose' in metadata) || metadata.purpose !== "block-json-inclusion-assurance") {
                     continue;
                 }
                 const entrypointChunk = entrypoint.getEntrypointChunk();

package/{build → dist}/plugins/PlainEntrypointsConfigFileGeneratorPlugin.js

@@ -1,10 +1,7 @@
 "use strict";
-var __importDefault = (this && this.__importDefault) || function (mod) {
-    return (mod && mod.__esModule) ? mod : { "default": mod };
-};
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.PlainEntrypointsConfigFileGeneratorPlugin = void 0;
-const node_path_1 = __importDefault(require("node:path"));
+const node_path_1 = require("node:path");
 const php_writer_1 = require("@plaudit/php-writer");
 const expressions_1 = require("@plaudit/php-writer/expressions");
 const shared_1 = require("../shared");
@@ -27,7 +24,7 @@ class PlainEntrypointsConfigFileGeneratorPlugin extends AbstractBiPhasicGroupAnd
         this.useUnifiedLoader = useUnifiedLoader;
     }
     generatePlainEntrypointsLoader(compilation, assets) {
-        const emitDir = node_path_1.default.join(this.buildRoot, this.outputDir);
+        const emitDir = (0, node_path_1.join)(this.buildRoot, this.outputDir);
         const handleLists = {
             register: [],
             inline: [],
@@ -44,14 +41,14 @@ class PlainEntrypointsConfigFileGeneratorPlugin extends AbstractBiPhasicGroupAnd
         const plainEntrypointsConfig = { scriptHandles: {}, script_moduleHandles: {}, styleHandles: {} };
         for (const { handles, handlePrefix } of assets) {
             for (const { src, rest, locations, type, handleName, lazyLoader, ...otherProps } of handles) {
-                const basename = node_path_1.default.basename(src).replace(/_(?:script(?:-\d+)?\.js|style(?:-\d+)?\.css)$|(?<!_(script|style))\.(js|css)$/, "");
+                const cleanBasename = (0, node_path_1.basename)(src).replace(/_(?:script(?:-\d+)?\.js|style(?:-\d+)?\.css)$|(?<!_(script|style))\.(js|css)$/, "");
                 let finalHandleName;
                 if (typeof handleName === 'string') {
-                    finalHandleName = (0, shared_1.convertUsageLocationsHandleToEmittableHandle)(handleName, basename);
+                    finalHandleName = (0, shared_1.convertUsageLocationsHandleToEmittableHandle)(handleName, cleanBasename);
                 }
                 else {
                     const handleNameMap = usedHandleNames[type];
-                    const baseFinalHandleName = finalHandleName = `${handlePrefix}.${(0, shared_1.convertUsageLocationsHandleToEmittableHandle)((0, shared_1.kebabCase)(basename), basename)}`;
+                    const baseFinalHandleName = finalHandleName = `${handlePrefix}.${(0, shared_1.convertUsageLocationsHandleToEmittableHandle)((0, shared_1.kebabCase)(cleanBasename), cleanBasename)}`;
                     for (let count = 0; finalHandleName in handleNameMap && handleNameMap[finalHandleName] !== src;) {
                         finalHandleName = `${baseFinalHandleName}-${++count}`;
                     }
@@ -83,7 +80,7 @@ class PlainEntrypointsConfigFileGeneratorPlugin extends AbstractBiPhasicGroupAnd
                     for (const { handle, type, data } of prioritizedHandleList) {
                         const { inlinedAsset, rest, src } = data;
                         const emittedSrc = inlinedAsset === undefined
-                            ? expressions_1.Op.concat(baseUriVar, node_path_1.default.relative(emitDir, src))
+                            ? expressions_1.Op.concat(baseUriVar, (0, node_path_1.relative)(emitDir, src))
                             : false;
                         writer.call(`wp_register_${type}`, [handle, emittedSrc, ...rest]);
                         if (inlinedAsset !== undefined) {
@@ -117,7 +114,7 @@ class PlainEntrypointsConfigFileGeneratorPlugin extends AbstractBiPhasicGroupAnd
         if (sortedEditorStyleHandles.length > 0) {
             writer.linebreak();
             for (const handleSrc of sortedEditorStyleHandles) {
-                const handlePath = node_path_1.default.join(this.outputDir, node_path_1.default.relative(emitDir, handleSrc));
+                const handlePath = (0, node_path_1.join)(this.outputDir, (0, node_path_1.relative)(emitDir, handleSrc));
                 writer.call("add_editor_style", [(0, shared_1.leadingSlashIt)(handlePath)]);
             }
         }
@@ -297,15 +294,15 @@ class PlainEntrypointsConfigFileGeneratorPlugin extends AbstractBiPhasicGroupAnd
                 chunkFiles[0][1] = true;
             }
             for (const [file, useHandleName] of chunkFiles) {
-                const extension = node_path_1.default.extname(file).toLowerCase();
+                const extension = (0, node_path_1.extname)(file).toLowerCase();
                 const type = extension === ".js" ? 'script' : (extension === ".mjs" ? 'script_module' : 'style');
                 const isScript = type !== 'style';
                 const dependencies = isScript === entrypointChunkIsScript ? assetData.dependencies : [];
                 const { lazyLoader, locations } = this.dest;
                 const { flags } = (0, path_query_and_related_helpers_1.unpackEnqueuingControlFlagsFromPathQueryParameters)(typeof locations.registerScriptArgs === 'object' ? locations.registerScriptArgs : { strategy: locations.registerScriptArgs }, file, "registerScriptArgs");
-                const { inlinedAsset, scriptArgsObject } = (0, path_query_and_related_helpers_1.convertEnqueuingControlFlagsToScriptArgsObject)(compilation, file, (0, path_query_and_related_helpers_1.mergeTwoScriptEnqueuingControlFlagSets)(file, flags, this.dest.enqueuingFlags));
+                const { inlinedAsset, scriptArgsObject } = (0, path_query_and_related_helpers_1.convertEnqueuingControlFlagsToScriptArgsObject)(compilation, file, (0, path_query_and_related_helpers_1.mergeTwoEnqueuingControlFlagSets)(file, flags, this.dest.enqueuingFlags));
                 const rest = isScript && scriptArgsObject !== undefined ? [dependencies, assetData.version, scriptArgsObject] : [dependencies, assetData.version];
-                const destPath = node_path_1.default.join(compilation.outputOptions.path, file);
+                const destPath = (0, node_path_1.join)(compilation.outputOptions.path, file);
                 handles.push({
                     src: destPath,
                     rest,

package/{build → dist}/shared.d.ts

@@ -1,6 +1,6 @@
 import { PHPWriter } from "@plaudit/php-writer";
 import type { Options as PostcssFunctionsOptions } from "postcss-functions";
-import { AssetInfo, Compilation, Configuration, Entrypoint, WebpackError, Compiler } from "webpack";
+import { type AssetInfo, type Compilation, type Configuration, type Entrypoint, WebpackError, type Compiler } from "webpack";
 import { SourceType } from "./utils/entrypoint-resolution-logic";
 import type { NormalizedEnqueuingControlFlags } from "./utils/path-query-and-related-helpers";
 export * from "./utils/entrypoint-resolution-logic";
@@ -221,6 +221,7 @@ export declare function arrayIsLength<T, N extends number>(arr: T[] | null | und
 export declare function kebabCase(value: string): string;
 export declare function loadEnvFile(filePath: string): Promise<Record<string, string>>;
 export declare function parseEnvFile(contents: string): Record<string, string>;
+export declare function newCleanWebpackError(error: string | ConstructorParameters<typeof WebpackError>): WebpackError;
 export declare function newWebpackErrorForFile(error: string | ConstructorParameters<typeof WebpackError>, file: string): WebpackError;
 /**
  * The primary benefit of emitting a function instead of baking its contents into each function that uses it is that it allows us to avoid recomputing the base uri multiple times

package/{build → dist}/shared.js

@@ -40,6 +40,7 @@ exports.arrayIsLength = arrayIsLength;
 exports.kebabCase = kebabCase;
 exports.loadEnvFile = loadEnvFile;
 exports.parseEnvFile = parseEnvFile;
+exports.newCleanWebpackError = newCleanWebpackError;
 exports.newWebpackErrorForFile = newWebpackErrorForFile;
 exports.emitResolveBaseUriFunction = emitResolveBaseUriFunction;
 exports.getAssetsJson = getAssetsJson;
@@ -201,9 +202,13 @@ function parseEnvFile(contents) {
         return equalsPos === -1 ? [line, ""] : [line.substring(0, equalsPos), line.substring(equalsPos + 1)];
     }));
 }
-function newWebpackErrorForFile(error, file) {
+function newCleanWebpackError(error) {
     const res = typeof error === 'string' ? new webpack_1.WebpackError(error) : new webpack_1.WebpackError(...error);
     res.hideStack = true;
+    return res;
+}
+function newWebpackErrorForFile(error, file) {
+    const res = newCleanWebpackError(error);
     res.file = file;
     return res;
 }

package/{build → dist}/utils/common-config-helpers.js

@@ -8,21 +8,21 @@ exports.groupEntrypointsByAssetFile = groupEntrypointsByAssetFile;
 exports.resolveEntryFromDirectory = resolveEntryFromDirectory;
 exports.commonMakeWebpackConfig = commonMakeWebpackConfig;
 const node_fs_1 = __importDefault(require("node:fs"));
-const promises_1 = __importDefault(require("node:fs/promises"));
-const node_path_1 = __importDefault(require("node:path"));
+const promises_1 = require("node:fs/promises");
+const node_path_1 = require("node:path");
 const location_encoding_filename_parser_1 = require("./location-encoding-filename-parser");
 const path_query_and_related_helpers_1 = require("./path-query-and-related-helpers");
 const shared_1 = require("../shared");
 const css_minimizer_webpack_plugin_1 = __importDefault(require("css-minimizer-webpack-plugin"));
 function joinPossiblyAbsolutePaths(...paths) {
     return paths.filter((p) => !!p)
-        .reduce((res, p) => !res || node_path_1.default.isAbsolute(p) ? p : node_path_1.default.join(res, p), '') || '.';
+        .reduce((res, p) => !res || (0, node_path_1.isAbsolute)(p) ? p : (0, node_path_1.join)(res, p), '') || '.';
 }
 function groupEntrypointsByAssetFile(entrypoints, entrypointNameExtractor) {
     const seenPaths = new Map();
     for (const entrypoint of entrypoints) {
         const entrypointName = entrypointNameExtractor(entrypoint);
-        const key = entrypointName.substring(0, entrypointName.length - node_path_1.default.extname(entrypointName).length);
+        const key = entrypointName.substring(0, entrypointName.length - (0, node_path_1.extname)(entrypointName).length);
         let seen = seenPaths.get(key);
         if (seen === undefined) {
             seenPaths.set(key, seen = []);
@@ -38,7 +38,7 @@ function mapToRealEntrypoints(entrypoint, dir, supportedExtensions, args) {
         .filter(ep => supportedExtensions(ep) && node_fs_1.default.statSync(ep, { throwIfNoEntry: false })?.isFile())
         .map(path_query_and_related_helpers_1.unpackPotentiallyPrefixedFilePath)
         .map(([ep, rawPathQueryParameters]) => {
-        const parsedEntrypoint = node_path_1.default.parse(ep);
+        const parsedEntrypoint = (0, node_path_1.parse)(ep);
         const entrypointField = shared_1.styleExtension.test(ep) ? 'style' : shared_1.scriptWithModuleExtension.test(ep) ? 'viewScriptModule' : 'script';
         const { flags: enqueuingFlags, remainder: pathQueryParameters } = (0, path_query_and_related_helpers_1.unpackEnqueuingControlFlagsFromPathQueryParameters)(rawPathQueryParameters, ep, 'path query parameters');
         const fakeEntrypointInfo = {
@@ -53,12 +53,12 @@ function mapToRealEntrypoints(entrypoint, dir, supportedExtensions, args) {
             pathQueryParameters,
             enqueuingFlags,
         };
-        return [joinPossiblyAbsolutePaths(dest.destination, node_path_1.default.basename(parsedEntrypoint.dir), parsedEntrypoint.name),
+        return [joinPossiblyAbsolutePaths(dest.destination, (0, node_path_1.basename)(parsedEntrypoint.dir), parsedEntrypoint.name),
             { import: [ep], plauditMetadata: fakeEntrypointInfo }];
     });
 }
 function parseEntrypointsJSON(dir, dest, supportedExtensions) {
-    const entrypointJsonOrigin = node_path_1.default.join(dir, 'entrypoints.json');
+    const entrypointJsonOrigin = (0, node_path_1.join)(dir, 'entrypoints.json');
     const entrypointsJSON = JSON.parse(node_fs_1.default.readFileSync(entrypointJsonOrigin, 'utf8'));
     if (Array.isArray(entrypointsJSON)) {
         return mapToRealEntrypoints(entrypointsJSON, dir, supportedExtensions, { dest, entrypointJsonOrigin });
@@ -101,7 +101,7 @@ function determineEntrypointType(entrypoint, scriptExtension) {
     }
 }
 function injectTypeAndCountToEntrypointName(entrypointName, type, typeCounts) {
-    const entrypointBasename = entrypointName.substring(0, entrypointName.length - node_path_1.default.extname(entrypointName).length);
+    const entrypointBasename = entrypointName.substring(0, entrypointName.length - (0, node_path_1.extname)(entrypointName).length);
     const parts = [];
     if (type) {
         parts.push(type);
@@ -110,7 +110,7 @@ function injectTypeAndCountToEntrypointName(entrypointName, type, typeCounts) {
         parts.push(typeCounts[type].toString());
     }
     typeCounts[type] += 1;
-    return `${entrypointBasename}_${parts.join('-')}${node_path_1.default.extname(entrypointName)}`;
+    return `${entrypointBasename}_${parts.join('-')}${(0, node_path_1.extname)(entrypointName)}`;
 }
 function addPotentiallyDuplicatedEntrypointName(entry, entrypoint, typeCounts, scriptExtension) {
     const type = determineEntrypointType(entrypoint, scriptExtension);
@@ -123,8 +123,9 @@ function addPotentiallyDuplicatedEntrypointName(entry, entrypoint, typeCounts, s
 function resolveEntryFromDirectory(commonConfig, srcRoot, dest) {
     const { entrypointFields, processingModules, scriptExtension } = commonConfig;
     return async () => {
+        const seenExplicitHandles = { scriptHandles: {}, styleHandles: {}, scriptModuleHandles: {} };
         const loadingEntrypoints = [];
-        for await (const dirent of await promises_1.default.opendir(srcRoot)) {
+        for await (const dirent of await (0, promises_1.opendir)(srcRoot)) {
             if (!dirent.isDirectory() || dirent.name.startsWith("~")) {
                 continue;
             }
@@ -133,9 +134,9 @@ function resolveEntryFromDirectory(commonConfig, srcRoot, dest) {
                 const rawEntrypoints = [];
                 const wpmlFiles = [];
                 try {
-                    const blockJsonOrigin = node_path_1.default.join(dir, 'block.json');
-                    const blockJson = JSON.parse(await promises_1.default.readFile(blockJsonOrigin, 'utf8'));
-                    const blockJsonChunkName = node_path_1.default.join(dest.destination, node_path_1.default.relative(srcRoot, dir), "block");
+                    const blockJsonOrigin = (0, node_path_1.join)(dir, 'block.json');
+                    const blockJson = JSON.parse(await (0, promises_1.readFile)(blockJsonOrigin, 'utf8'));
+                    const blockJsonChunkName = (0, node_path_1.join)(dest.destination, (0, node_path_1.relative)(srcRoot, dir), "block");
                     const filesRegisteredByJson = [];
                     const presentEntrypoints = (await Promise.all(entrypointFields
                         .filter(entrypointField => entrypointField in blockJson)
@@ -143,34 +144,36 @@ function resolveEntryFromDirectory(commonConfig, srcRoot, dest) {
                         return (Array.isArray(blockJson[entrypointField]) ? blockJson[entrypointField] : [blockJson[entrypointField]])
                             .filter(originalValue => typeof originalValue === 'string')
                             .filter(originalValue => originalValue?.startsWith("file:"))
-                            .map(originalValue => {
+                            .map(async (originalValue) => {
                             const [entrypointPath, rawLocalPathQueryParameters] = (0, path_query_and_related_helpers_1.unpackPotentiallyPrefixedFilePath)(originalValue);
-                            const absoluteSrc = node_path_1.default.normalize(node_path_1.default.join(dir, entrypointPath));
+                            const absoluteSrc = (0, node_path_1.normalize)((0, node_path_1.join)(dir, entrypointPath));
                             filesRegisteredByJson.push(absoluteSrc);
-                            const { flags: localEnqueuingFlags, remainder: localPathQueryParameters } = (0, path_query_and_related_helpers_1.unpackEnqueuingControlFlagsFromPathQueryParameters)(rawLocalPathQueryParameters, absoluteSrc, "path query parameters");
-                            const enqueuingFlags = (0, path_query_and_related_helpers_1.mergeTwoScriptEnqueuingControlFlagSets)(absoluteSrc, localEnqueuingFlags, dest.enqueuingFlags);
+                            const { flags: localEnqueuingFlags, handle, remainder: localPathQueryParameters } = (0, path_query_and_related_helpers_1.unpackEnqueuingControlFlagsFromPathQueryParameters)(rawLocalPathQueryParameters, absoluteSrc, "path query parameters");
+                            const enqueuingFlags = (0, path_query_and_related_helpers_1.mergeTwoEnqueuingControlFlagSets)(absoluteSrc, localEnqueuingFlags, dest.enqueuingFlags);
                             const pathQueryParameters = { ...dest.pathQueryParameters, ...localPathQueryParameters };
-                            return promises_1.default.stat(absoluteSrc)
-                                .then(stats => {
-                                if (stats.isFile()) {
-                                    const parsedEntrypoint = node_path_1.default.parse(node_path_1.default.normalize(node_path_1.default.join(dest.destination, node_path_1.default.relative(srcRoot, dir), entrypointPath)));
-                                    const extensionlessExpectedSrc = node_path_1.default.normalize(node_path_1.default.join(parsedEntrypoint.dir, parsedEntrypoint.name));
-                                    const entrypointName = node_path_1.default.normalize(joinPossiblyAbsolutePaths(parsedEntrypoint.dir, parsedEntrypoint.name));
-                                    return { entrypointField, originalValue, entrypointName, extensionlessExpectedSrc, absoluteSrc, pathQueryParameters, enqueuingFlags };
-                                }
-                                else {
+                            try {
+                                const stats = await (0, promises_1.stat)(absoluteSrc);
+                                if (!stats.isFile()) {
                                     return undefined;
                                 }
-                            }, () => undefined);
+                                const parsedEntrypoint = (0, node_path_1.parse)((0, node_path_1.normalize)((0, node_path_1.join)(dest.destination, (0, node_path_1.relative)(srcRoot, dir), entrypointPath)));
+                                const extensionlessExpectedSrc = (0, node_path_1.normalize)((0, node_path_1.join)(parsedEntrypoint.dir, parsedEntrypoint.name));
+                                const entrypointName = (0, node_path_1.normalize)(joinPossiblyAbsolutePaths(parsedEntrypoint.dir, parsedEntrypoint.name));
+                                return { entrypointField, originalValue, entrypointName, extensionlessExpectedSrc, absoluteSrc, pathQueryParameters, enqueuingFlags, handle };
+                            }
+                            catch {
+                                return undefined;
+                            }
                         });
-                    }))).filter(pe => pe !== undefined);
-                    for await (const dirent of await promises_1.default.opendir(dir)) {
+                    })))
+                        .filter(pe => pe !== undefined);
+                    for await (const dirent of await (0, promises_1.opendir)(dir)) {
                         if (!dirent.isFile()) {
                             continue;
                         }
-                        const absoluteSrc = node_path_1.default.normalize(node_path_1.default.join(dir, dirent.name));
+                        const absoluteSrc = (0, node_path_1.normalize)((0, node_path_1.join)(dir, dirent.name));
                         if (filesRegisteredByJson.includes(absoluteSrc)) {
-                            continue;
+                            continue; //TODO: Should we make it so that encoded location data is merged in for files loaded via block.json?
                         }
                         const parsedFilename = (0, location_encoding_filename_parser_1.parseLocationEncodingFilenameForBlock)(absoluteSrc);
                         if (!parsedFilename) {
@@ -200,10 +203,10 @@ function resolveEntryFromDirectory(commonConfig, srcRoot, dest) {
                                 entrypointField = (location.substring(6).toLowerCase() + type.substring(0, 1).toUpperCase() + type.substring(1));
                             }
                         }
-                        const parsedEntrypoint = node_path_1.default.parse(node_path_1.default.normalize(node_path_1.default.join(dest.destination, node_path_1.default.relative(srcRoot, dir), `./${dirent.name}`)));
-                        const extensionlessExpectedSrc = node_path_1.default.normalize(node_path_1.default.join(parsedEntrypoint.dir, parsedEntrypoint.name));
-                        const entrypointName = node_path_1.default.normalize(joinPossiblyAbsolutePaths(parsedEntrypoint.dir, parsedEntrypoint.name));
-                        const enqueuingFlags = (0, path_query_and_related_helpers_1.mergeTwoScriptEnqueuingControlFlagSets)(absoluteSrc, flags, dest.enqueuingFlags);
+                        const parsedEntrypoint = (0, node_path_1.parse)((0, node_path_1.normalize)((0, node_path_1.join)(dest.destination, (0, node_path_1.relative)(srcRoot, dir), `./${dirent.name}`)));
+                        const extensionlessExpectedSrc = (0, node_path_1.normalize)((0, node_path_1.join)(parsedEntrypoint.dir, parsedEntrypoint.name));
+                        const entrypointName = (0, node_path_1.normalize)(joinPossiblyAbsolutePaths(parsedEntrypoint.dir, parsedEntrypoint.name));
+                        const enqueuingFlags = (0, path_query_and_related_helpers_1.mergeTwoEnqueuingControlFlagSets)(absoluteSrc, flags, dest.enqueuingFlags);
                         presentEntrypoints.push({
                             entrypointField,
                             originalValue: dirent.name,
@@ -211,7 +214,8 @@ function resolveEntryFromDirectory(commonConfig, srcRoot, dest) {
                             extensionlessExpectedSrc,
                             absoluteSrc,
                             pathQueryParameters: dest.pathQueryParameters,
-                            enqueuingFlags
+                            enqueuingFlags,
+                            handle: undefined
                         });
                     }
                     const entrypointNamesWithEffectiveDuplicates = presentEntrypoints
@@ -224,12 +228,15 @@ function resolveEntryFromDirectory(commonConfig, srcRoot, dest) {
                     const allocatedDestinations = {};
                     const resolvedBlockEntrypoints = presentEntrypoints
                         .map(presentEntrypoint => {
-                        const overallSource = node_path_1.default.dirname(blockJsonOrigin);
-                        const overallSourceRelativeName = node_path_1.default.relative(overallSource, node_path_1.default.normalize(node_path_1.default.join(blockJsonOrigin, node_path_1.default.relative(overallSource, presentEntrypoint.extensionlessExpectedSrc))));
+                        const overallSource = (0, node_path_1.dirname)(blockJsonOrigin);
+                        const overallSourceRelativeName = (0, node_path_1.relative)(overallSource, (0, node_path_1.normalize)((0, node_path_1.join)(blockJsonOrigin, (0, node_path_1.relative)(overallSource, presentEntrypoint.extensionlessExpectedSrc))));
                         const handleSuffix = (0, shared_1.convertUsageLocationsHandleToEmittableHandle)(dest.locations.handle, overallSourceRelativeName);
                         const handleGroup = (0, shared_1.getHandleGroup)(presentEntrypoint.entrypointField);
+                        if (presentEntrypoint.handle) {
+                            (seenExplicitHandles[handleGroup][presentEntrypoint.handle] ??= []).push(overallSource);
+                        }
                         if (!entrypointNamesWithEffectiveDuplicates[presentEntrypoint.entrypointName]) {
-                            return { blockJsonOrigin, ...presentEntrypoint, handle: `${handlePrefix}/${handleSuffix}`, dest, handleGroup };
+                            return { blockJsonOrigin, ...presentEntrypoint, handle: presentEntrypoint.handle ?? `${handlePrefix}/${handleSuffix}`, dest, handleGroup };
                         }
                         const baseSuffix = `_${(0, shared_1.isStyleField)(presentEntrypoint.entrypointField) ? "style" : "script"}`;
                         let count = 0, suffix = baseSuffix, deduplicatedEntrypointName;
@@ -244,7 +251,7 @@ function resolveEntryFromDirectory(commonConfig, srcRoot, dest) {
                             ...presentEntrypoint,
                             entrypointName: deduplicatedEntrypointName,
                             extensionlessExpectedSrc: deduplicatedExtensionlessExpectedSrc,
-                            handle: `${handlePrefix}/${count ? handleSuffix + "_" + count : handleSuffix}`, handleGroup,
+                            handle: presentEntrypoint.handle ?? `${handlePrefix}/${count ? handleSuffix + "_" + count : handleSuffix}`, handleGroup,
                             dest
                         };
                     });
@@ -259,12 +266,12 @@ function resolveEntryFromDirectory(commonConfig, srcRoot, dest) {
                         ];
                     }));
                     rawEntrypoints.push([blockJsonChunkName, { import: [blockJsonOrigin], plauditMetadata: { purpose: "block-json-inclusion-assurance", dest, absoluteSrc: blockJsonOrigin } }]);
-                    wpmlFiles.push(node_path_1.default.join(dir, 'block.json'));
+                    wpmlFiles.push((0, node_path_1.join)(dir, 'block.json'));
                 }
                 catch (e) {
                     try {
-                        const packageJsonOrigin = node_path_1.default.join(dir, 'package.json');
-                        const packageJson = JSON.parse(await promises_1.default.readFile(packageJsonOrigin, 'utf8'));
+                        const packageJsonOrigin = (0, node_path_1.join)(dir, 'package.json');
+                        const packageJson = JSON.parse(await (0, promises_1.readFile)(packageJsonOrigin, 'utf8'));
                         if (packageJson['main']) {
                             rawEntrypoints.push(...mapToRealEntrypoints(packageJson['main'], dir, commonConfig.scriptExtension.test, { dest, entrypointJsonOrigin: packageJsonOrigin }));
                         }
@@ -283,8 +290,8 @@ function resolveEntryFromDirectory(commonConfig, srcRoot, dest) {
                 }
                 if (!processingModules) {
                     try {
-                        const wpmlFilePath = node_path_1.default.join(dir, "wpml-config.xml");
-                        await promises_1.default.access(wpmlFilePath);
+                        const wpmlFilePath = (0, node_path_1.join)(dir, "wpml-config.xml");
+                        await (0, promises_1.access)(wpmlFilePath);
                         wpmlFiles.push(wpmlFilePath);
                     }
                     catch (e) {
@@ -296,6 +303,13 @@ function resolveEntryFromDirectory(commonConfig, srcRoot, dest) {
         }
         const allEntrypoints = await Promise.all(loadingEntrypoints);
         const perAssetPathGroupedEntrypoints = groupEntrypointsByAssetFile(allEntrypoints.flatMap(e => e[0]), e => e[0]);
+        const conflictingHandles = Object.values(seenExplicitHandles)
+            .flatMap(handles => Object.entries(handles))
+            .filter(([, sources]) => sources.length > 0)
+            .map(([handle, sources]) => `${handle}: ${sources.join(", ")}`);
+        if (conflictingHandles.length > 0) {
+            throw (0, shared_1.newCleanWebpackError)("Encountered conflicting explicitly-set handles:\n" + conflictingHandles.join("\n"));
+        }
         const currentEntry = {};
         for (const groupedEntrypoints of perAssetPathGroupedEntrypoints.values()) {
             if (groupedEntrypoints.length === 1 && groupedEntrypoints[0] !== undefined) {
@@ -310,10 +324,10 @@ function resolveEntryFromDirectory(commonConfig, srcRoot, dest) {
         }
         if (!processingModules) {
             const wpmlEntrypointFiles = allEntrypoints.flatMap(e => e[1]);
-            const absoluteSrc = node_path_1.default.join(srcRoot, "wpml-config.xml");
+            const absoluteSrc = (0, node_path_1.join)(srcRoot, "wpml-config.xml");
             try {
-                await promises_1.default.access(absoluteSrc);
-                currentEntry["wpml-config.xml"] = { import: [node_path_1.default.join(srcRoot, "wpml-config.xml"), ...wpmlEntrypointFiles], plauditMetadata: { purpose: "wpml-config-xml", dest, absoluteSrc } };
+                await (0, promises_1.access)(absoluteSrc);
+                currentEntry["wpml-config.xml"] = { import: [(0, node_path_1.join)(srcRoot, "wpml-config.xml"), ...wpmlEntrypointFiles], plauditMetadata: { purpose: "wpml-config-xml", dest, absoluteSrc } };
             }
             catch (e) {
                 // If the wpml-config.xml file does not exist, just "import" the other files that will be used to build the emitted version
@@ -333,14 +347,14 @@ function commonMakeWebpackConfig(config, commonConfig, webpackConfig, externaliz
     let viableRoots = [...(Array.isArray(webpackConfig.context) ? webpackConfig.context : [webpackConfig.context ?? process.cwd()])];
     let wpContentHolderDirectory = process.cwd();
     while (wpContentHolderDirectory.length > 5) {
-        if (node_path_1.default.basename(wpContentHolderDirectory) === 'wp-content') {
-            wpContentHolderDirectory = node_path_1.default.dirname(wpContentHolderDirectory);
+        if ((0, node_path_1.basename)(wpContentHolderDirectory) === 'wp-content') {
+            wpContentHolderDirectory = (0, node_path_1.dirname)(wpContentHolderDirectory);
             if (wpContentHolderDirectory.length > 5) {
                 viableRoots.push(wpContentHolderDirectory);
             }
             break;
         }
-        wpContentHolderDirectory = node_path_1.default.dirname(wpContentHolderDirectory);
+        wpContentHolderDirectory = (0, node_path_1.dirname)(wpContentHolderDirectory);
     }
     const distinctViableRoots = new Set();
     viableRoots = viableRoots.filter(value => distinctViableRoots.has(value) ? false : distinctViableRoots.add(value) && true);
@@ -387,16 +401,16 @@ function commonMakeWebpackConfig(config, commonConfig, webpackConfig, externaliz
                 ...(webpackConfig.optimization?.splitChunks || {}),
                 cacheGroups: {
                     style: {
-                        // This is a flagrant abuse of cache groups, but it fixes a persistent problem wherein the dependencies and versions of scripts and styles were bleeding into each-other
+                        // This is a flagrant abuse of cache groups, but it fixes a persistent problem wherein the dependencies and versions of scripts and styles were bleeding into each other
                         type: 'css/mini-extract',
                         chunks: 'all',
                         enforce: true,
                         name(_, chunks, cacheGroupKey) {
                             const chunkName = chunks.find(chunk => chunk.name)?.name;
                             // We use "__${cacheGroupKey}__" instead of "${cacheGroupKey}-" to make it easier to remove when generating the filename
-                            const filename = `__${cacheGroupKey}__${node_path_1.default.basename(chunkName)}`;
-                            const dirname = node_path_1.default.dirname(chunkName);
-                            return dirname === '.' ? filename : `${dirname}/${filename}`;
+                            const filename = `__${cacheGroupKey}__${(0, node_path_1.basename)(chunkName)}`;
+                            const chunkDirname = (0, node_path_1.dirname)(chunkName);
+                            return chunkDirname === '.' ? filename : `${chunkDirname}/${filename}`;
                         }
                     },
                     default: false

package/{build → dist}/utils/path-query-and-related-helpers.d.ts

@@ -1,5 +1,5 @@
 import type { Compilation } from "webpack";
-import { InlinedAsset, PathQueryParameters, ScriptArgsObject } from "../shared";
+import { type InlinedAsset, type PathQueryParameters, type ScriptArgsObject } from "../shared";
 export declare function getAssetFileContents(compilation: Compilation, name: string): string;
 export declare function unpackPotentiallyPrefixedFilePath(filePath: string): [string, PathQueryParameters | undefined];
 /**
@@ -36,9 +36,10 @@ export type NormalizedEnqueuingControlFlags = {
     fetchpriority?: FetchPriority;
     position?: 'before' | 'after';
 };
-export declare function mergeTwoScriptEnqueuingControlFlagSets(file: string, baseArgs: NormalizedEnqueuingControlFlags | undefined, ancestorArgs: NormalizedEnqueuingControlFlags | undefined): NormalizedEnqueuingControlFlags | undefined;
+export declare function mergeTwoEnqueuingControlFlagSets(file: string, baseArgs: NormalizedEnqueuingControlFlags | undefined, ancestorArgs: NormalizedEnqueuingControlFlags | undefined): NormalizedEnqueuingControlFlags | undefined;
 export declare function unpackEnqueuingControlFlagsFromPathQueryParameters(pathQueryParameters: PathQueryParameters | undefined, file: string, sourceType: 'registerScriptArgs' | 'path query parameters'): {
     flags?: NormalizedEnqueuingControlFlags;
+    handle?: string;
     remainder?: PathQueryParameters;
 };
 /**

package/{build → dist}/utils/path-query-and-related-helpers.js

@@ -11,7 +11,7 @@ exports.isValidFetchPriority = isValidFetchPriority;
 exports.newInvalidFetchPriorityError = newInvalidFetchPriorityError;
 exports.isValidPositionForInlineStrategy = isValidPositionForInlineStrategy;
 exports.newInvalidPositionForInlineStrategyError = newInvalidPositionForInlineStrategyError;
-exports.mergeTwoScriptEnqueuingControlFlagSets = mergeTwoScriptEnqueuingControlFlagSets;
+exports.mergeTwoEnqueuingControlFlagSets = mergeTwoEnqueuingControlFlagSets;
 exports.unpackEnqueuingControlFlagsFromPathQueryParameters = unpackEnqueuingControlFlagsFromPathQueryParameters;
 exports.convertEnqueuingControlFlagsToScriptArgsObject = convertEnqueuingControlFlagsToScriptArgsObject;
 const node_path_1 = require("node:path");
@@ -102,7 +102,7 @@ function isValidPositionForInlineStrategy(position) {
 function newInvalidPositionForInlineStrategyError(position, file) {
     return (0, shared_1.newWebpackErrorForFile)(`The position value for the inlined asset was invalid. Received: ${position}, Expected: undefined|'before'|'after'`, file);
 }
-function mergeTwoScriptEnqueuingControlFlagSets(file, baseArgs, ancestorArgs) {
+function mergeTwoEnqueuingControlFlagSets(file, baseArgs, ancestorArgs) {
     if (baseArgs === undefined) {
         return ancestorArgs;
     }
@@ -126,7 +126,7 @@ function unpackEnqueuingControlFlagsFromPathQueryParameters(pathQueryParameters,
     if (pathQueryParameters === undefined) {
         return {};
     }
-    const { strategy, in_footer: normalizedInFooter, 'in-footer': alternateInFooter, fetchpriority, position, ...remainder } = pathQueryParameters;
+    const { strategy, in_footer: normalizedInFooter, 'in-footer': alternateInFooter, fetchpriority, position, handle, ...remainder } = pathQueryParameters;
     let flags;
     switch (strategy) {
         case 'defer':
@@ -175,7 +175,10 @@ function unpackEnqueuingControlFlagsFromPathQueryParameters(pathQueryParameters,
     if (flags.inline && (pathQueryParameters['position'] === 'before' || pathQueryParameters['position'] === 'after')) {
         flags.position = pathQueryParameters['position'];
     }
-    return Object.keys(flags).length > 0 ? { flags, remainder } : { remainder };
+    if (handle !== undefined && (typeof handle !== 'string' || handle.length < 5)) {
+        throw (0, shared_1.newWebpackErrorForFile)(`The handle was invalid. Received: ${handle}. Expected: a string that is at least 5 characters long`, file);
+    }
+    return Object.keys(flags).length > 0 ? { flags, handle, remainder } : { handle, remainder };
 }
 /**
  * This function does a few things:

package/{build → dist}/wordpress-scripts-wrapper.js

@@ -213,7 +213,7 @@ function buildVerifiedConfig(config) {
     const partiallyVerifiedSources = rawSources.map(rawSource => {
         const { destination, additionalDependencies = [], assumeGlobalizedPlauditLibraries = cfg.assumeGlobalizedPlauditLibraries, bundleAnalyzer = false, directoryLayout, externalize, withLegacyBlocksIn = false, lazyLoader, pathQueryParameters: rawPathQueryParameters, enqueuingFlags: rawEnqueuingFlags } = rawSource[1];
         const { flags: queryEnqueuingFlags, remainder: pathQueryParameters } = (0, path_query_and_related_helpers_1.unpackEnqueuingControlFlagsFromPathQueryParameters)(rawPathQueryParameters, rawSource[0], 'path query parameters');
-        const enqueuingFlags = (0, path_query_and_related_helpers_1.mergeTwoScriptEnqueuingControlFlagSets)(rawSource[0], rawEnqueuingFlags, queryEnqueuingFlags);
+        const enqueuingFlags = (0, path_query_and_related_helpers_1.mergeTwoEnqueuingControlFlagSets)(rawSource[0], rawEnqueuingFlags, queryEnqueuingFlags);
         const normalizedParts = { additionalDependencies, assumeGlobalizedPlauditLibraries, bundleAnalyzer, directoryLayout, externalize, withLegacyBlocksIn, lazyLoader };
         const locations = typeof rawSource[1].locations === 'string' || typeof rawSource[1].locations === 'function'
             ? { handle: rawSource[1].locations } : rawSource[1].locations ?? {};

package/package.json

@@ -1,55 +1,55 @@
 {
   "name": "@plaudit/webpack-extensions",
-  "version": "3.4.1",
+  "version": "3.5.1",
   "license": "SEE LICENSE IN LICENSE.md",
   "files": [
-    "/build",
+    "/dist",
     "README.md",
     "LICENSE.md",
     "CHANGELOG.md",
     "USER-GUIDE.md"
   ],
   "exports": {
-    "./wordpress-scripts-wrapper": "./build/wordpress-scripts-wrapper.js",
-    "./location-encoding-filename-parser": "./build/utils/location-encoding-filename-parser.js",
-    "./shared": "./build/shared.js"
+    "./wordpress-scripts-wrapper": "./dist/wordpress-scripts-wrapper.js",
+    "./location-encoding-filename-parser": "./dist/utils/location-encoding-filename-parser.js",
+    "./shared": "./dist/shared.js"
   },
   "typesVersions": {
     "*": {
       "wordpress-scripts-wrapper": [
-        "build/wordpress-scripts-wrapper.d.ts"
+        "dist/wordpress-scripts-wrapper.d.ts"
       ],
       "location-encoding-filename-parser": [
-        "build/location-encoding-filename-parser.d.ts"
+        "dist/location-encoding-filename-parser.d.ts"
       ],
       "shared": [
-        "build/shared.d.ts"
+        "dist/shared.d.ts"
       ]
     }
   },
   "devDependencies": {
-    "@plaudit/gutenberg-api-extensions": "^2.87.0",
+    "@plaudit/gutenberg-api-extensions": "^2.89.0",
     "@types/browser-sync-webpack-plugin": "^2.2.5",
     "@types/node": "^25.5.0",
     "@types/postcss-functions": "^4.0.4",
     "@types/postcss-import": "^14.0.3",
     "@types/tapable": "^2.3.0",
     "@types/webpack-sources": "^3.2.3",
-    "typescript": "^5.9.3",
-    "webpack-bundle-analyzer": "^5.2.0"
+    "typescript": "^6.0.2",
+    "webpack-bundle-analyzer": "^5.3.0"
   },
   "dependencies": {
     "@plaudit/php-writer": "^1.4.1",
     "@plaudit/postcss-color-function": "^5.0.0",
     "@plaudit/postcss-strip-units": "^3.0.0",
     "@plaudit/postcss-variables": "^2.0.1",
-    "@wordpress/dependency-extraction-webpack-plugin": "^6.41.0",
-    "@wordpress/scripts": "^31.6.0",
+    "@wordpress/dependency-extraction-webpack-plugin": "^6.42.0",
+    "@wordpress/scripts": "^31.7.0",
     "autoprefixer": "^10.4.27",
     "browser-sync": "^3.0.4",
     "copy-webpack-plugin": "10.2.4",
-    "css-minimizer-webpack-plugin": "^7.0.4",
-    "cssnano": "^7.1.3",
+    "css-minimizer-webpack-plugin": "^8.0.0",
+    "cssnano": "^7.1.4",
     "fork-ts-checker-webpack-plugin": "^9.1.0",
     "http-proxy-middleware": "^3.0.5",
     "json2php": "^0.0.12",
@@ -72,7 +72,7 @@
   },
   "scripts": {
     "build": "tsc",
-    "clean": "rm -rf build",
+    "clean": "rm -rf dist",
     "build:clean": "pnpm run clean && pnpm run build",
     "watch": "tsc -w"
   }

package/{build → dist}/plugins/EnhancedBlockJSONPlugin.d.ts

@@ -1,8 +1,8 @@
+import { Compilation } from "webpack";
+import type WebpackRemoveEmptyScriptsPlugin from "webpack-remove-empty-scripts";
 import { AbstractBiPhasicGroupAndEntryPlugin, EntryProvider } from "./AbstractBiPhasicGroupAndEntryPlugin";
 import { ParsedAssetsJson, BlockEntrypointInfo, FileSegmentBlockEntrypointInfo, VerifiedAdvancedOutputConfig, ParsedAssetJsonProvider, ScriptArgsObject, InlinedAsset } from "../shared";
 import type { VerifiedPlauditWordpressWebpackConfig } from "../utils/common-config-helpers";
-import { Compilation } from "webpack";
-import type WebpackRemoveEmptyScriptsPlugin from "webpack-remove-empty-scripts";
 type WorkableBlockEntrypointInfo = Omit<FileSegmentBlockEntrypointInfo, 'originalValue' | 'pathQueryParameters'> & Partial<Pick<FileSegmentBlockEntrypointInfo, 'originalValue'>> & {
     outputPath: string;
     assetData: ParsedAssetsJson[string];