@10up/wp-vite-plugins 1.0.0-alpha.0 → 1.0.0-alpha.2

package/dist/index.js

@@ -1,5 +1,5 @@
 import { resolve, join, relative, dirname, extname } from 'path';
-import { readdirSync, existsSync, readFileSync } from 'fs';
+import { readdirSync, existsSync, readFileSync, realpathSync } from 'fs';
 import crypto, { createHash } from 'crypto';
 import fg from 'fast-glob';
 import { init, parse } from 'es-module-lexer';
@@ -1586,8 +1586,36 @@ function discoverEntries(blocksDirAbs, buildType, skip) {
   }
   return entries;
 }
+function normalizePath(filePath) {
+  try {
+    return realpathSync.native(filePath);
+  } catch {
+    return filePath;
+  }
+}
+var MARKER_PROPERTY = "--wp-vite-entry";
+var MARKER_DECLARATION_RE = new RegExp(
+  `${MARKER_PROPERTY}\\s*:\\s*(?:"[^"]*"|'[^']*')\\s*;?`,
+  "g"
+);
+var EMPTY_ROOT_RULE_RE = /:root\s*\{\s*\}/g;
+function markerRule(entryName, isIndentedSass) {
+  if (isIndentedSass) {
+    return `
+:root
+	${MARKER_PROPERTY}: "${entryName}"
+`;
+  }
+  return `
+:root{${MARKER_PROPERTY}:"${entryName}"}
+`;
+}
+function stripMarker(source) {
+  return source.replace(MARKER_DECLARATION_RE, "").replace(EMPTY_ROOT_RULE_RE, "");
+}
 function wpBlockStyles(options) {
   let stylesDirAbs;
+  const entryNameByFile = /* @__PURE__ */ new Map();
   return {
     name: "wp-block-styles",
     enforce: "pre",
@@ -1597,10 +1625,13 @@ function wpBlockStyles(options) {
         `${stylesDirAbs.replace(/\\/g, "/")}/**/*.{css,scss,sass}`,
         { absolute: true }
       );
+      entryNameByFile.clear();
       const entries = {};
       for (const filePath of stylesheets) {
         const blockName = relative(stylesDirAbs, filePath).replace(extname(filePath), "").replace(/\\/g, "/");
-        entries[`autoenqueue/${blockName}`] = filePath;
+        const entryName = `autoenqueue/${blockName}`;
+        entries[entryName] = filePath;
+        entryNameByFile.set(normalizePath(filePath), entryName);
       }
       return {
         build: {
@@ -1609,6 +1640,38 @@ function wpBlockStyles(options) {
           }
         }
       };
+    },
+    transform(code, id) {
+      const [rawPath] = id.split("?");
+      const filePath = normalizePath(rawPath);
+      const entryName = entryNameByFile.get(filePath);
+      if (!entryName) return null;
+      return code + markerRule(entryName, extname(rawPath) === ".sass");
+    },
+    generateBundle(_options, bundle) {
+      const expected = /* @__PURE__ */ new Map();
+      for (const [filePath, entryName] of entryNameByFile) {
+        expected.set(`${entryName}.css`, filePath);
+      }
+      for (const output of Object.values(bundle)) {
+        if (output.type !== "asset" || !expected.has(output.fileName)) continue;
+        if (typeof output.source === "string") {
+          output.source = stripMarker(output.source);
+        } else {
+          output.source = Buffer.from(
+            stripMarker(Buffer.from(output.source).toString("utf-8"))
+          );
+        }
+      }
+      const missing = [];
+      for (const [fileName, filePath] of expected) {
+        if (!(fileName in bundle)) missing.push(`${fileName} (from ${filePath})`);
+      }
+      if (missing.length > 0) {
+        throw new Error(
+          "wpBlockStyles: expected stylesheet(s) missing from the build output \u2014 each source under blocksStylesDir must produce its own dist file:\n" + missing.map((entry) => `  - ${entry}`).join("\n")
+        );
+      }
     }
   };
 }
@@ -1683,8 +1746,75 @@ function isScriptModule(metadata, subpath) {
 function camelize(kebabCaseName) {
   return kebabCaseName.replace(/-(.)/g, (_match, letter) => letter.toUpperCase());
 }
+function pickExportsEntry(value) {
+  if (typeof value === "string") return value;
+  if (Array.isArray(value)) {
+    for (const candidate of value) {
+      const picked = pickExportsEntry(candidate);
+      if (picked) return picked;
+    }
+    return null;
+  }
+  if (!value || typeof value !== "object") return null;
+  const record = value;
+  if ("." in record) return pickExportsEntry(record["."]);
+  for (const condition of ["module", "import", "browser", "default"]) {
+    if (!(condition in record)) continue;
+    const picked = pickExportsEntry(record[condition]);
+    if (picked) return picked;
+  }
+  return null;
+}
+function resolvePackageEsmEntry(packageName, fromPaths) {
+  for (const from of fromPaths) {
+    const packageJsonPath = findPackageJson(packageName, from);
+    if (!packageJsonPath) continue;
+    let metadata;
+    try {
+      metadata = JSON.parse(readFileSync(packageJsonPath, "utf8"));
+    } catch {
+      continue;
+    }
+    const entry = pickExportsEntry(metadata.exports) ?? (typeof metadata.module === "string" ? metadata.module : null) ?? (typeof metadata.main === "string" ? metadata.main : null) ?? "./index.js";
+    const entryPath = resolve(dirname(packageJsonPath), entry);
+    if (!existsSync(entryPath)) continue;
+    try {
+      return realpathSync(entryPath);
+    } catch {
+      return entryPath;
+    }
+  }
+  return null;
+}
+function findPackageJson(packageName, from) {
+  try {
+    return createRequire(from).resolve(`${packageName}/package.json`);
+  } catch {
+  }
+  let dir = dirname(from);
+  for (; ; ) {
+    const candidate = join(dir, "node_modules", packageName, "package.json");
+    if (existsSync(candidate)) return candidate;
+    const parent = dirname(dir);
+    if (parent === dir) return null;
+    dir = parent;
+  }
+}
 
 // src/wp-externals.ts
+var DEFAULT_BUNDLED_PACKAGES = ["@wordpress/icons"];
+var BUNDLED_MARKER_PREFIX = "wp-vite-bundled:";
+var JS_SOURCE_EXTENSION = /\.[mc]?[jt]sx?$/;
+function escapeRegExp(value) {
+  return value.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+}
+function isBarePackageName(name) {
+  if (name.startsWith("@")) {
+    const parts = name.split("/");
+    return parts.length === 2 && parts[0].length > 1 && !!parts[1];
+  }
+  return name.length > 0 && !name.includes("/") && !name.startsWith(".");
+}
 var DEFAULT_VENDOR = {
   react: { global: "React", handle: "react" },
   "react-dom": { global: "ReactDOM", handle: "react-dom" },
@@ -1737,6 +1867,14 @@ function wpExternals(options = {}) {
   const moduleEntryMatchers = options.moduleEntryMatchers ?? [];
   const wpBuildAssetMatchers = options.wpBuildAssetMatchers ?? [];
   const scriptModuleNamespaces = options.scriptModuleNamespaces ?? [];
+  for (const name of options.bundle ?? []) {
+    if (isBarePackageName(name)) continue;
+    const { name: rootName, subpath } = splitImport(name);
+    throw new Error(
+      `wpExternals: \`bundle\` accepts bare package names only, got '${name}'.` + (subpath ? ` Force-bundling is a whole-package verdict \u2014 list '${rootName}' instead of the '${subpath}' subpath.` : "")
+    );
+  }
+  const bundledPackages = /* @__PURE__ */ new Set([...DEFAULT_BUNDLED_PACKAGES, ...options.bundle ?? []]);
   function matchesScriptModuleNamespace(packageName) {
     if (!packageName.startsWith("@")) return false;
     const slashIndex = packageName.indexOf("/");
@@ -1767,6 +1905,7 @@ function wpExternals(options = {}) {
     return false;
   }
   function resolveExternal(specifier) {
+    if (bundledPackages.has(splitImport(specifier).name)) return null;
     if (vendorExternals[specifier]) {
       const vendor = vendorExternals[specifier];
       return {
@@ -1897,9 +2036,15 @@ function wpExternals(options = {}) {
       await init;
       let imports;
       try {
-        [imports] = parse(code);
-      } catch {
-        return null;
+        [imports] = parse(code, id);
+      } catch (error) {
+        const filePath = id.split("?")[0] ?? id;
+        if (!JS_SOURCE_EXTENSION.test(filePath)) return null;
+        return this.error(
+          `wp-externals could not parse the imports of ${filePath}: ${error instanceof Error ? error.message : String(error)}
+Its @wordpress/* imports would ship un-rewritten (broken window.wp.* reads and an incomplete .asset.php), so this is a hard error.
+Most likely cause: JSX in a file that isn't .jsx/.tsx. JSX must live in .jsx/.tsx files \u2014 do not use \`rollupOptions.moduleTypes\` to map .js to jsx; rename the files instead. The JSX transform runs *after* plugin transform hooks, so \`moduleTypes\` makes the build pass while this plugin still sees raw JSX and produces broken output.`
+        );
       }
       if (imports.length === 0) return null;
       const magicString = new MagicString(code);
@@ -2062,27 +2207,388 @@ function wpExternals(options = {}) {
       }
     }
   };
-  return [resolverPlugin, transformPlugin];
+  const bundlePlugin = {
+    name: `wp-externals-bundle(${buildType})`,
+    enforce: "pre",
+    transform(code, id) {
+      if (bundledPackages.size === 0) return null;
+      if (id.startsWith("\0")) return null;
+      const filePath = (id.split("?")[0] ?? id).replace(/\\/g, "/");
+      const magicString = new MagicString(code);
+      let codeChanged = false;
+      for (const packageName of bundledPackages) {
+        if (!code.includes(packageName)) continue;
+        if (filePath.includes(`/node_modules/${packageName}/`)) continue;
+        const pattern = new RegExp(
+          `(?:\\bfrom|\\bimport|\\brequire)\\s*\\(?\\s*(['"])${escapeRegExp(
+            packageName
+          )}\\1`,
+          "g"
+        );
+        for (const match of code.matchAll(pattern)) {
+          const end = match.index + match[0].length - 1;
+          magicString.overwrite(
+            end - packageName.length,
+            end,
+            BUNDLED_MARKER_PREFIX + packageName
+          );
+          codeChanged = true;
+        }
+      }
+      if (!codeChanged) return null;
+      return {
+        code: magicString.toString(),
+        map: magicString.generateMap({ hires: true })
+      };
+    },
+    resolveId(source, importer) {
+      if (!source.startsWith(BUNDLED_MARKER_PREFIX)) return null;
+      const packageName = source.slice(BUNDLED_MARKER_PREFIX.length);
+      const fromPaths = [
+        ...importer && !importer.startsWith("\0") ? [importer.split("?")[0]] : [],
+        join(projectRoot, "package.json")
+      ];
+      const entry = resolvePackageEsmEntry(packageName, fromPaths);
+      if (!entry) {
+        return this.error(
+          `wp-externals is configured to bundle '${packageName}' (see the \`bundle\` option), but the package is not installed${importer ? ` \u2014 resolved from ${importer} and ` : " under "}${projectRoot}.
+Force-bundling requires the package in node_modules, since its code has to be compiled into your output. Run \`npm install ${packageName}\`.`
+        );
+      }
+      return entry;
+    }
+  };
+  return [resolverPlugin, transformPlugin, bundlePlugin];
+}
+var MARKER_PARAM = "wp-entry";
+var MARKER_RE = new RegExp(`[?&]${MARKER_PARAM}=([^&]*)`);
+var PARTITIONABLE_EXTENSION = /\.[cm]?[jt]sx?$/;
+var INLINABLE_SYNTHETIC_ID = [/^\0?rolldown[:/]runtime(\.[cm]?js)?$/, /^\0wp-external-global:/];
+function markerOf(id) {
+  return id.match(MARKER_RE)?.[1];
+}
+function withMarker(id, marker) {
+  return `${id}${id.includes("?") ? "&" : "?"}${MARKER_PARAM}=${marker}`;
+}
+function stripEntryMarker(id) {
+  return id.replace(
+    new RegExp(`([?&])${MARKER_PARAM}=[^&]*&?`),
+    (_match, lead) => lead === "?" ? "?" : "&"
+  ).replace(/[?&]$/, "");
+}
+function mintMarker(entryId) {
+  return crypto.createHash("sha1").update(entryId).digest("hex").slice(0, 8);
+}
+function isPartitionable(id) {
+  if (id.includes("\0") || id.includes("?")) return false;
+  return PARTITIONABLE_EXTENSION.test(id);
+}
+function isInlinableSyntheticChunk(chunk) {
+  const moduleIds = Object.keys(chunk.modules ?? {});
+  if (moduleIds.length === 0) return false;
+  return moduleIds.every((id) => INLINABLE_SYNTHETIC_ID.some((pattern) => pattern.test(id)));
+}
+function objectKey(name) {
+  return JSON.stringify(name);
+}
+function parseImportClause(statement) {
+  const match = statement.match(/^\s*import\s*(?:([\s\S]*?)\s*from\s*)?['"][^'"]*['"]\s*;?\s*$/);
+  if (!match) return null;
+  const bindings = match[1]?.trim();
+  if (!bindings) return { named: [] };
+  const clause = { named: [] };
+  let rest = bindings;
+  const leadingDefault = rest.match(/^([A-Za-z_$][\w$]*)\s*(?:,\s*([\s\S]*))?$/);
+  if (leadingDefault) {
+    clause.default = leadingDefault[1];
+    rest = leadingDefault[2]?.trim() ?? "";
+  }
+  if (rest.startsWith("*")) {
+    const namespace = rest.match(/^\*\s*as\s+([A-Za-z_$][\w$]*)$/);
+    if (!namespace) return null;
+    clause.namespace = namespace[1];
+    return clause;
+  }
+  if (rest.startsWith("{")) {
+    if (!rest.endsWith("}")) return null;
+    for (const binding of rest.slice(1, -1).split(",")) {
+      const trimmed = binding.trim();
+      if (!trimmed) continue;
+      const aliased = trimmed.match(/^([A-Za-z_$][\w$]*)\s+as\s+([A-Za-z_$][\w$]*)$/);
+      if (aliased) {
+        clause.named.push({ imported: aliased[1], local: aliased[2] });
+        continue;
+      }
+      if (!/^[A-Za-z_$][\w$]*$/.test(trimmed)) return null;
+      clause.named.push({ imported: trimmed, local: trimmed });
+    }
+    return clause;
+  }
+  return rest === "" ? clause : null;
+}
+function exportClauseRange(code, exports) {
+  let firstName = Number.POSITIVE_INFINITY;
+  let lastName = -1;
+  for (const record of exports) {
+    firstName = Math.min(firstName, record.s, record.ls >= 0 ? record.ls : record.s);
+    lastName = Math.max(lastName, record.e, record.le >= 0 ? record.le : record.e);
+  }
+  if (lastName < 0) return null;
+  const brace = code.lastIndexOf("{", firstName);
+  if (brace < 0) return null;
+  const beforeBrace = code.slice(0, brace).trimEnd();
+  if (!beforeBrace.endsWith("export")) return null;
+  const start = beforeBrace.length - "export".length;
+  if (start > 0 && /[\w$]/.test(code[start - 1])) return null;
+  const close = code.indexOf("}", lastName);
+  if (close < 0) return null;
+  let end = close + 1;
+  while (end < code.length && /\s/.test(code[end])) end += 1;
+  if (code[end] === ";") end += 1;
+  if (!/^export\s*\{[^{}]*\}\s*;?$/.test(code.slice(start, end))) return null;
+  return { start, end };
+}
+function toInlineExpression(code) {
+  const [imports, exports] = parse(code);
+  if (imports.length > 0) return null;
+  let body = code;
+  if (exports.length > 0) {
+    const range = exportClauseRange(code, exports);
+    if (!range) return null;
+    body = code.slice(0, range.start) + code.slice(range.end);
+  }
+  try {
+    const [bodyImports, bodyExports] = parse(body);
+    if (bodyImports.length > 0 || bodyExports.length > 0) return null;
+  } catch {
+    return null;
+  }
+  const returned = exports.map((record) => `${objectKey(record.n)}: ${record.ln ?? record.n}`).join(", ");
+  return `(() => {
+${body.trim()}
+;
+return { ${returned} };
+})()`;
+}
+function resolveChunkSpecifier(hostFileName, specifier) {
+  const segments = hostFileName.split("/").slice(0, -1);
+  for (const segment of specifier.split("/")) {
+    if (segment === "." || segment === "") continue;
+    if (segment === "..") segments.pop();
+    else segments.push(segment);
+  }
+  return segments.join("/");
+}
+function shiftMappings(map, atLine, addedLines) {
+  if (!map || typeof map.mappings !== "string" || addedLines <= 0) return;
+  const lines = map.mappings.split(";");
+  if (atLine > lines.length) return;
+  lines.splice(atLine + 1, 0, ...new Array(addedLines).fill(""));
+  map.mappings = lines.join(";");
+}
+function wpScriptDedupe() {
+  const inFlight = /* @__PURE__ */ new Set();
+  return {
+    name: "wp-script-dedupe",
+    // Mandatory: normal-bucket `resolveId` hooks are never called during a
+    // Vite 8 build — Rolldown's native resolver answers between the `pre`
+    // and normal buckets.
+    enforce: "pre",
+    apply: "build",
+    resolveId: {
+      // `enforce: 'pre'` alone only puts this plugin in the pre bucket —
+      // *within* it, array position decides, and any pre-bucket resolver
+      // registered earlier answers first and hands back an untagged id.
+      // wpExternals' force-bundle resolver is exactly that: it answers
+      // `wp-vite-bundled:@wordpress/icons` itself, so the barrel came back
+      // unpartitioned and its whole subtree inherited one marker minted
+      // from the barrel — identical for every entry, i.e. a shared chunk
+      // (issue #23). Hook-level `order: 'pre'` puts this resolver ahead of
+      // every other resolveId hook no matter how the plugins are composed;
+      // it delegates through `this.resolve`, so those resolvers still
+      // decide *what* an id resolves to. This plugin only tags the answer.
+      order: "pre",
+      async handler(source, importer, options) {
+        if (!importer) return null;
+        if (source.includes("\0")) return null;
+        const key = `${importer}
+${source}`;
+        if (inFlight.has(key)) return null;
+        const marker = markerOf(importer) ?? mintMarker(importer);
+        inFlight.add(key);
+        let resolved;
+        try {
+          resolved = await this.resolve(
+            stripEntryMarker(source),
+            stripEntryMarker(importer),
+            {
+              // `kind` rides along so plugins keying on `require-call`
+              // (wpExternals' CJS shim) still see the truth.
+              ...options,
+              skipSelf: true
+            }
+          );
+        } finally {
+          inFlight.delete(key);
+        }
+        if (!resolved || resolved.external) return resolved;
+        if (!isPartitionable(resolved.id)) return resolved;
+        return { ...resolved, id: withMarker(resolved.id, marker) };
+      }
+    },
+    generateBundle: {
+      // Load-bearing, not cosmetic: wpExternals emits its `.asset.php`
+      // sidecars from `generateBundle`, unioning the dependencies of every
+      // chunk an entry reaches — including the synthetic shim chunks this
+      // hook inlines and deletes. Rolldown hands each plugin a freshly built
+      // `bundle` object and drops `modules` mutations on write-back
+      // (`collectChangedBundle` sends `modules: {}`), so the merge below
+      // cannot be what keeps that union correct under Vite 8 — running after
+      // the sidecars are emitted is.
+      order: "post",
+      async handler(_outputOptions, bundle) {
+        await init;
+        let inlinedSomething = true;
+        while (inlinedSomething) {
+          inlinedSomething = false;
+          for (const [fileName, chunk] of Object.entries(bundle)) {
+            if (chunk.type !== "chunk") continue;
+            if (chunk.isEntry || chunk.isDynamicEntry) continue;
+            if (!isInlinableSyntheticChunk(chunk)) continue;
+            const expression = toInlineExpression(chunk.code);
+            if (!expression) continue;
+            let consumers = 0;
+            let failures = 0;
+            for (const [hostFileName, host] of Object.entries(bundle)) {
+              if (host.type !== "chunk" || hostFileName === fileName) continue;
+              if (!(host.imports ?? []).includes(fileName)) continue;
+              consumers += 1;
+              if (!inlineChunkInto(host, hostFileName, fileName, expression)) {
+                failures += 1;
+                continue;
+              }
+              absorbChunkMetadata(host, chunk, fileName);
+            }
+            if (consumers > 0 && failures === 0) {
+              delete bundle[fileName];
+              inlinedSomething = true;
+            }
+          }
+        }
+        for (const [fileName, chunk] of Object.entries(bundle)) {
+          if (chunk.type !== "chunk" || chunk.isEntry || chunk.isDynamicEntry) continue;
+          const consumers = Object.entries(bundle).filter(
+            ([, host]) => host.type === "chunk" && (host.imports ?? []).includes(fileName)
+          ).map(([hostFileName]) => hostFileName);
+          if (consumers.length === 0) continue;
+          const moduleIds = Object.keys(chunk.modules ?? {});
+          const unpartitionable = moduleIds.filter(
+            (id) => !id.includes("\0") && !PARTITIONABLE_EXTENSION.test(id.split("?")[0])
+          );
+          this.warn(
+            `wp-script-dedupe: shared chunk ${fileName} could not be duplicated into its consumers (${consumers.join(", ")}). It holds: ${moduleIds.join(", ")}. ` + (unpartitionable.length > 0 ? `Only JS/TS modules can be partitioned per entry, so a shared non-JS module (${unpartitionable.join(", ")}) stays in a chunk a classic script cannot import. Re-export it from a per-entry .ts module, give each entry its own copy, or build these entries in module mode.` : `A classic script cannot import, so those entries will not load \u2014 report the module list above upstream.`)
+          );
+        }
+      }
+    }
+  };
+}
+function absorbChunkMetadata(host, inlined, inlinedFileName) {
+  host.modules = { ...host.modules, ...inlined.modules };
+  host.moduleIds = [.../* @__PURE__ */ new Set([...host.moduleIds ?? [], ...inlined.moduleIds ?? []])];
+  host.imports = (host.imports ?? []).filter((imported) => imported !== inlinedFileName);
+  const importedBindings = host.importedBindings;
+  if (importedBindings) delete importedBindings[inlinedFileName];
+  mergeViteMetadata(host, inlined);
+}
+function mergeViteMetadata(host, inlined) {
+  const hostMetadata = host.viteMetadata;
+  const inlinedMetadata = inlined.viteMetadata;
+  if (!hostMetadata || !inlinedMetadata) return;
+  for (const cssFileName of inlinedMetadata.importedCss ?? []) {
+    hostMetadata.importedCss?.add(cssFileName);
+  }
+  for (const assetFileName of inlinedMetadata.importedAssets ?? []) {
+    hostMetadata.importedAssets?.add(assetFileName);
+  }
+}
+function inlineChunkInto(host, hostFileName, targetFileName, expression) {
+  const [imports] = parse(host.code);
+  const replacements = [];
+  let counter = 0;
+  for (const record of imports) {
+    if (record.d !== -1) continue;
+    if (!record.n) continue;
+    if (resolveChunkSpecifier(hostFileName, record.n) !== targetFileName) continue;
+    const clause = parseImportClause(host.code.slice(record.ss, record.se));
+    if (!clause) return false;
+    const named = clause.named.map(({ imported, local }) => `${objectKey(imported)}: ${local}`).join(", ");
+    let code;
+    if (clause.default || clause.namespace && clause.named.length > 0) {
+      const temp = `__wpInlined${counter++}`;
+      const parts = [`const ${temp} = ${expression};`];
+      if (clause.default) parts.push(`const ${clause.default} = ${temp}["default"];`);
+      if (clause.namespace) parts.push(`const ${clause.namespace} = ${temp};`);
+      if (named) parts.push(`const { ${named} } = ${temp};`);
+      code = parts.join("\n");
+    } else if (clause.namespace) {
+      code = `const ${clause.namespace} = ${expression};`;
+    } else if (named) {
+      code = `const { ${named} } = ${expression};`;
+    } else {
+      code = `${expression};`;
+    }
+    replacements.push({ start: record.ss, end: record.se, code });
+  }
+  if (replacements.length === 0) return false;
+  const magicString = new MagicString(host.code);
+  for (const replacement of replacements.reverse()) {
+    magicString.overwrite(replacement.start, replacement.end, replacement.code);
+    const line = host.code.slice(0, replacement.start).split("\n").length - 1;
+    const addedLines = replacement.code.split("\n").length - host.code.slice(replacement.start, replacement.end).split("\n").length;
+    shiftMappings(host.map, line, addedLines);
+  }
+  host.code = magicString.toString();
+  return true;
 }
 
 // src/wp-script-iife.ts
+var CLASSIC_SCRIPT_DEFINE = {
+  "import.meta.url": "document.currentScript && document.currentScript.src",
+  "import.meta.resolve": "undefined"
+};
+var LIVE_MODULE_STATEMENT = /^[ \t]*(?:import\s*(?:[{*"']|[A-Za-z_$][\w$]*\s*(?:,|from\b))|export\s*(?:[{*]|(?:default|const|let|var|function|class|async)\b))[^\n]*/m;
 function wpScriptIife() {
   return {
     name: "wp-script-iife",
+    // Build-only. Vite filters plugins by `apply` before it runs `config`,
+    // which is what keeps the `import.meta` define below out of `vite serve`
+    // — the dev server ships real ESM to the browser, where `import.meta.url`
+    // is both legal and load-bearing.
+    apply: "build",
+    config(userConfig) {
+      const define = {};
+      for (const [key, value] of Object.entries(CLASSIC_SCRIPT_DEFINE)) {
+        if (userConfig.define && key in userConfig.define) continue;
+        define[key] = value;
+      }
+      return Object.keys(define).length > 0 ? { define } : null;
+    },
     async writeBundle(options, bundle) {
       const { readFile, writeFile } = await import('fs/promises');
-      const { join: join4 } = await import('path');
+      const { join: join5 } = await import('path');
       const outDir = options.dir ?? ".";
       for (const [fileName, output] of Object.entries(bundle)) {
         if (output.type !== "chunk") continue;
         if (!fileName.endsWith(".js") && !fileName.endsWith(".mjs")) continue;
         if (!output.isEntry && !output.isDynamicEntry) continue;
-        const filePath = join4(outDir, fileName);
+        const filePath = join5(outDir, fileName);
         let chunkSource = await readFile(filePath, "utf8");
         const sideEffectImport = /^\s*import\s+["'][^"']+["'];?\s*\n?/;
         while (sideEffectImport.test(chunkSource)) {
           chunkSource = chunkSource.replace(sideEffectImport, "");
         }
+        assertClassicScript(fileName, chunkSource, output.isEntry !== true);
         await writeFile(filePath, `(()=>{
 ${chunkSource}
 })();
@@ -2091,6 +2597,37 @@ ${chunkSource}
     }
   };
 }
+function assertClassicScript(fileName, code, isDynamicOnly = false) {
+  let parseError;
+  try {
+    new Function(code);
+    return;
+  } catch (error) {
+    if (!(error instanceof SyntaxError)) throw error;
+    parseError = error;
+  }
+  const liveStatement = code.match(LIVE_MODULE_STATEMENT);
+  if (liveStatement) {
+    const specifiers = [...code.matchAll(/^[ \t]*(?:import|export)\b[^\n]*?["']([^"']+)["']/gm)].map((match) => match[1]).filter((specifier, index, all) => all.indexOf(specifier) === index);
+    throw new Error(
+      `wp-script-iife: ${fileName} still contains a top-level module statement, which is a SyntaxError once WordPress enqueues it as a classic script:
+    ${liveStatement[0].trim()}
+` + (specifiers.length > 0 ? `  Imported chunk(s): ${specifiers.join(", ")}
+` : "") + (isDynamicOnly ? `  This file is a dynamic-import chunk, so it needs its \`export\`s and cannot be an IIFE. A script-mode entry can't lazily load one either (WP has no module context to resolve it in) \u2014 drop the dynamic \`import()\`, or build this entry in module mode.` : `  This is almost always a shared chunk: a module two or more script-mode entries import gets hoisted into its own chunk instead of being duplicated into each entry. Add the wpScriptDedupe() plugin (auto-included by wp() in script mode \u2014 check you haven't set \`scriptDedupe: false\`), or build this entry in module mode.`)
+    );
+  }
+  if (/\bimport\.meta\b/.test(code)) {
+    throw new Error(
+      `wp-script-iife: ${fileName} references \`import.meta\`, which is a SyntaxError once WordPress enqueues it as a classic script.
+  Vite injects its module-preload helper (which reads \`import.meta.url\`) whenever the bundled graph contains a dynamic \`import()\` \u2014 \`build.modulePreload: false\` does not remove it. This plugin's \`config()\` hook defines \`import.meta.url\`/\`import.meta.resolve\` away; a surviving reference means either that define was overridden, or the code touches another \`import.meta\` member. Extend \`define\` in your Vite config, or move this entry to module mode.`
+    );
+  }
+  throw new Error(
+    `wp-script-iife: ${fileName} does not parse as a classic script, so WordPress could not load it:
+    ${parseError.message}
+  Nothing in this plugin's usual suspects (a shared chunk's \`import\`, an \`import.meta\` reference) explains it \u2014 inspect the written file, and report it upstream if the source is valid.`
+  );
+}
 
 // src/wp-clean-css-chunks.ts
 function wpCleanCssChunks() {
@@ -2107,8 +2644,66 @@ function wpCleanCssChunks() {
     }
   };
 }
+var STYLESHEET_EXTENSION = /\.(css|scss|sass)$/i;
+function wpCssAssetInfo() {
+  const cssEntries = /* @__PURE__ */ new Map();
+  return {
+    name: "wp-css-asset-info",
+    configResolved(config) {
+      cssEntries.clear();
+      const input = config.build?.rollupOptions?.input;
+      if (!input || typeof input !== "object" || Array.isArray(input)) return;
+      for (const [entryName, source] of Object.entries(input)) {
+        if (typeof source === "string" && STYLESHEET_EXTENSION.test(source)) {
+          cssEntries.set(entryName, source);
+        }
+      }
+    },
+    generateBundle: {
+      // MUST be post: wpBlockStyles strips its dedup markers from CSS
+      // assets in its own normal-order generateBundle, and the version has
+      // to hash the FINAL shipped bytes, not the pre-strip content.
+      order: "post",
+      handler(_outputOptions, bundle) {
+        for (const [entryName, sourcePath] of cssEntries) {
+          const expectedFileName = `${entryName}.css`;
+          const cssAsset = findCssAsset(bundle, expectedFileName, sourcePath);
+          if (!cssAsset) continue;
+          const assetPhpFileName = cssAsset.fileName.replace(/\.css$/i, ".asset.php");
+          if (bundle[assetPhpFileName]) continue;
+          const version = crypto.createHash("md5").update(cssAsset.source).digest("hex");
+          this.emitFile({
+            type: "asset",
+            fileName: assetPhpFileName,
+            source: `<?php return array( 'dependencies' => array(), 'version' => '${version}' );
+`
+          });
+        }
+      }
+    }
+  };
+}
+function findCssAsset(bundle, expectedFileName, sourcePath) {
+  const direct = bundle[expectedFileName];
+  if (direct && direct.type === "asset") return direct;
+  for (const output of Object.values(bundle)) {
+    if (output.type !== "asset") continue;
+    if (output.names?.includes(expectedFileName)) return output;
+    if (output.originalFileNames?.some((name) => sourcePath.endsWith(name))) return output;
+  }
+  return void 0;
+}
 
 // src/wp.ts
+function wpModuleEntrySignatures() {
+  return {
+    name: "wp-module-entry-signatures",
+    config(userConfig) {
+      if (userConfig.build?.rollupOptions?.preserveEntrySignatures !== void 0) return null;
+      return { build: { rollupOptions: { preserveEntrySignatures: "exports-only" } } };
+    }
+  };
+}
 function wp(options = {}) {
   const buildType = options.buildType ?? "script";
   const plugins = [];
@@ -2180,15 +2775,24 @@ function wp(options = {}) {
       })
     );
   }
+  if (buildType === "script" && options.scriptDedupe !== false) {
+    plugins.push(wpScriptDedupe());
+  }
   if (buildType === "script" && options.iife !== false) {
     plugins.push(wpScriptIife());
   }
   if (options.cleanCssChunks !== false) {
     plugins.push(wpCleanCssChunks());
   }
+  if (options.cssAssetInfo !== false) {
+    plugins.push(wpCssAssetInfo());
+  }
+  if (buildType === "module") {
+    plugins.push(wpModuleEntrySignatures());
+  }
   return plugins;
 }
 
-export { wp, wpAdminPages, wpBlockStyles, wpBlocks, wpCleanCssChunks, wpCopyAssets, wpExternals, wpScriptIife };
+export { DEFAULT_BUNDLED_PACKAGES, wp, wpAdminPages, wpBlockStyles, wpBlocks, wpCleanCssChunks, wpCopyAssets, wpCssAssetInfo, wpExternals, wpScriptDedupe, wpScriptIife };
 //# sourceMappingURL=index.js.map
 //# sourceMappingURL=index.js.map