packages/unhead/src/server/createHead.ts (1)

14-14: Redundant renderer creation.

createServerRenderer({ tagWeight: capoTagWeight }) is called twice: once at line 14 (passed to createUnhead) and again at line 50. The first renderer is immediately discarded when head.render is overridden at line 54.

Consider passing a no-op or lightweight stub to createUnhead since its renderer is unused:

♻️ Suggested refactor to avoid redundant allocation

-  const core = createUnhead<T, SSRHeadPayload>(createServerRenderer({ tagWeight: capoTagWeight }), {
+  const core = createUnhead<T, SSRHeadPayload>(() => ({} as SSRHeadPayload), {
     _tagWeight: capoTagWeight,

Alternatively, document why both are needed if there's a reason not immediately apparent.

Also applies to: 50-54

🤖 Prompt for AI Agents

Verify each finding against the current code and only fix it if needed.

In `@packages/unhead/src/server/createHead.ts` at line 14, The code creates a real
server renderer twice—once passed into createUnhead and again when overriding
head.render—wasting allocation; modify the implementation so
createServerRenderer({ tagWeight: capoTagWeight }) is only created once and
reused for head.render, or pass a lightweight/no-op stub renderer into
createUnhead (instead of the full createServerRenderer) and keep the actual
renderer assigned to head.render; locate createUnhead, createServerRenderer and
head.render in the file and replace the redundant createServerRenderer call with
either the reused renderer instance or a minimal stub implementation so the
expensive renderer is not allocated twice.

packages/addons/src/unplugin/MinifyTransform.ts (3)

118-125: Consider handling parse errors gracefully.

parseSync from oxc-parser may throw on syntax errors in the source file. If this happens during the transform hook, it could fail the build. Since this runs on user code, a try/catch with a warning might provide better DX.

Optional: Graceful parse error handling

    async transform(code, id) {
      if (!code.includes('useHead') && !code.includes('useServerHead'))
        return

+     let ast
+     try {
+       ast = parseSync(id, code)
+     }
+     catch (e) {
+       // Let the main compiler handle syntax errors
+       return
+     }
+
      const scopeTracker = new ScopeTracker()
-     const ast = parseSync(id, code)
      const s = new MagicString(code)

🤖 Prompt for AI Agents

Verify each finding against the current code and only fix it if needed.

In `@packages/addons/src/unplugin/MinifyTransform.ts` around lines 118 - 125, The
transform hook currently calls parseSync(id, code) which can throw on syntax
errors; wrap that call in a try/catch inside the async transform function
(before using ScopeTracker, MagicString, and pendingMinifications) and on catch
emit a non-fatal warning that includes the id and the error message (e.g.,
this.warn or console.warn) and then return null or the original code to avoid
failing the build; ensure subsequent logic only runs when parseSync succeeded.

---

101-105: Include filter takes precedence over exclude—verify this is intentional.

The current ordering checks include first (returns true) before exclude (returns false). This means a file matching both patterns will be processed. The conventional expectation is often that exclude takes precedence.

If this is intentional, consider documenting it in the MinifyTransformOptions interface.

🤖 Prompt for AI Agents

Verify each finding against the current code and only fix it if needed.

In `@packages/addons/src/unplugin/MinifyTransform.ts` around lines 101 - 105, The
include-vs-exclude precedence in MinifyTransform.ts currently returns true if
options.filter.include matches before checking options.filter.exclude, so a file
matching both will be processed; decide which behavior you want and either (A)
change the runtime logic in the match path to check options.filter.exclude first
(if a match, return false) then check options.filter.include (return true) to
make exclude take precedence, or (B) keep the current order but document the
intentional precedence by adding a clear note to the MinifyTransformOptions
interface (and comments near the matching code) stating that include wins over
exclude; update unit tests accordingly to reflect the chosen precedence.

---

47-61: Empty catch blocks silently swallow minifier import/execution failures.

Both rolldown and esbuild fallback paths have empty catch blocks. While this enables graceful degradation when dependencies aren't available, it also silently swallows actual minification errors (e.g., syntax errors in the JS being minified).

Consider whether build-time syntax errors in inline scripts should surface to the developer rather than pass through silently.

Optional: Log warnings on minification failures

      try {
        const rolldownPath = 'rolldown/experimental'
        const { minify } = await import(/* `@vite-ignore` */ rolldownPath) as { minify: (filename: string, code: string) => Promise<{ code: string }> }
        const result = await minify('inline.js', code)
        return result.code.trim()
      }
-     catch {}
+     catch (e) {
+       // Fallback to esbuild if rolldown unavailable
+       if (!(e instanceof Error && e.message.includes('Cannot find'))) {
+         console.warn('[unhead:minify] JS minification failed:', e)
+       }
+     }

🤖 Prompt for AI Agents

Verify each finding against the current code and only fix it if needed.

In `@packages/addons/src/unplugin/MinifyTransform.ts` around lines 47 - 61, The
empty catch blocks in MinifyTransform (around the dynamic import of
rolldownPath/minify and the esbuild.transform fallback) silently swallow errors;
change each catch to capture the error (e.g., catch (err)) and emit a clear
warning including which minifier failed, the identifier 'inline.js', and the
error details (use console.warn or an existing logger) so minification failures
are visible while still allowing the next fallback to run; keep the graceful
fallback behavior but ensure the final failure path returns null only after
logging the last error.

packages/unhead/test/unit/plugins/minify.test.ts (2)

68-84: Consider adding coverage for importmap type.

The SKIP_JS_TYPES set includes both speculationrules and importmap, but only speculationrules is tested. Adding a similar test for importmap would ensure complete coverage of the skip logic.

🤖 Prompt for AI Agents

Verify each finding against the current code and only fix it if needed.

In `@packages/unhead/test/unit/plugins/minify.test.ts` around lines 68 - 84, Add a
test mirroring the existing speculationrules case to cover the importmap skip
path: in the test file use createServerHeadWithContext with MinifyPlugin(), push
a script tag with type 'importmap' and innerHTML set to a JSON string (similar
to speculationContent), call head.render() and assert that headTags contains the
raw JSON string; this ensures the SKIP_JS_TYPES logic (including 'importmap') is
exercised alongside the existing speculationrules test.

---

49-66: Consider adding a test for malformed JSON-LD resilience.

The current tests verify happy-path JSON-LD minification. Given that minifyJSON throws on invalid JSON (and the related issue flagged in minify.ts), consider adding a test that verifies the plugin doesn't crash when encountering malformed JSON-LD content.

Suggested test case (once the fix is applied to minify.ts)

it('handles malformed JSON-LD gracefully', () => {
  const head = createServerHeadWithContext({
    plugins: [MinifyPlugin()],
  })
  const invalidJson = '{ "name": "test", invalid }'
  head.push({
    script: [{
      type: 'application/ld+json',
      innerHTML: invalidJson,
    }],
  })

  // Should not throw and should preserve original content
  const { headTags } = head.render()
  expect(headTags).toContain(invalidJson)
})

🤖 Prompt for AI Agents

Verify each finding against the current code and only fix it if needed.

In `@packages/unhead/test/unit/plugins/minify.test.ts` around lines 49 - 66, Add a
unit test that verifies MinifyPlugin and its minifyJSON handling are resilient
to malformed JSON-LD: using createServerHeadWithContext({ plugins:
[MinifyPlugin()] }), push a script with type 'application/ld+json' whose
innerHTML is invalid JSON (e.g. '{ "name": "test", invalid }'), call
head.render(), and assert that render does not throw and that headTags contains
the original invalid JSON string (i.e., the plugin preserved the content instead
of crashing or removing it). This ensures minifyJSON errors are caught and
original innerHTML is left unchanged.

packages/addons/src/unplugin/MinifyTransform.ts (2)

242-254: Template literal gets converted to string literal.

When minifying a template literal (backticks), the replacement uses JSON.stringify(minified) which produces a double-quoted string literal. This is semantically equivalent but changes the code style. Ensure this is the intended behavior, especially if the original template literal relied on different escaping rules (e.g., unescaped single quotes).

If preserving template literal syntax is desired:

♻️ Alternative to preserve template literal syntax

       else if (prop.value?.type === 'TemplateLiteral' && prop.value.expressions.length === 0) {
         const raw = prop.value.quasis[0]?.value?.cooked as string
         if (!raw || raw.length < 20)
           continue

         pendingMinifications.push(
           minifyStringContent(raw, tagType).then((minified) => {
             if (minified && minified.length < raw.length) {
-              s.overwrite(prop.value.start, prop.value.end, JSON.stringify(minified))
+              // Escape backticks and ${} for template literal preservation
+              const escaped = minified.replace(/`/g, '\\`').replace(/\$\{/g, '\\${')
+              s.overwrite(prop.value.start, prop.value.end, `\`${escaped}\``)
             }
           }),
         )
       }

🤖 Prompt for AI Agents

Verify each finding against the current code and only fix it if needed.

In `@packages/addons/src/unplugin/MinifyTransform.ts` around lines 242 - 254, The
current replacement turns a TemplateLiteral into a double-quoted string because
you call JSON.stringify(minified) when prop.value.type === 'TemplateLiteral' in
MinifyTransform.ts; to preserve original template-literal syntax (since there
are no expressions) change the overwrite to write a backtick-wrapped literal
instead of JSON.stringify: build a string that escapes backticks, backslashes
and any "${" sequences in the minified text and then call
s.overwrite(prop.value.start, prop.value.end, '`' + escapedMinified + '`'); keep
using the existing minifyStringContent, pendingMinifications and prop/value
checks and only switch to backtick-escaping logic when prop.value.type ===
'TemplateLiteral' and prop.value.expressions.length === 0.

---

47-61: Consider logging minifier initialization failures for debuggability.

The empty catch blocks silently swallow errors, making it difficult to diagnose why minification might not be working (e.g., missing dependencies, version mismatches). A debug-level log would help users troubleshoot.

♻️ Proposed improvement

       try {
         const rolldownPath = 'rolldown/experimental'
         const { minify } = await import(/* `@vite-ignore` */ rolldownPath) as { minify: (filename: string, code: string) => Promise<{ code: string }> }
         const result = await minify('inline.js', code)
         return result.code.trim()
       }
-      catch {}
+      catch (e) {
+        // rolldown not available, will try esbuild fallback
+      }
       // esbuild fallback (Vite 7)
       try {
         const esbuild = await import('esbuild' as string) as { transform: (code: string, opts: { minify: boolean, loader: string }) => Promise<{ code: string }> }
         const result = await esbuild.transform(code, { minify: true, loader: 'js' })
         return result.code.trim()
       }
-      catch {}
+      catch (e) {
+        // esbuild not available either
+      }
       return null

🤖 Prompt for AI Agents

Verify each finding against the current code and only fix it if needed.

In `@packages/addons/src/unplugin/MinifyTransform.ts` around lines 47 - 61, The
two empty catch blocks in MinifyTransform.ts silently swallow errors for the
dynamic imports and minification attempts (rolldownPath/minify and
esbuild.transform); update both catch blocks to log the caught Error at debug
level (include a descriptive message and the error object), e.g., console.debug
or the module's logger, so failures to import or run
rolldown/experimental.minify and esbuild.transform are recorded with context
(mentioning the symbol names minify and esbuild.transform and the rolldownPath)
before proceeding to the next fallback or returning null.

Fix all unresolved CodeRabbit comments on this PR:

• Push a commit to this branch (recommended)
• Create a new PR with the fixes