domflax 0.1.0 → 0.1.1

package/dist/cli.cjs

@@ -176,8 +176,7 @@ init_cjs_shims();
 // ../cli/src/index.ts
 init_cjs_shims();
 var import_node_fs2 = require("fs");
-var path5 = __toESM(require("path"), 1);
-var import_node_url = require("url");
+var path6 = __toESM(require("path"), 1);
 
 // ../cli/src/options.ts
 init_cjs_shims();
@@ -507,6 +506,9 @@ function elementIds(doc) {
 
 // ../core/src/ops.ts
 init_cjs_shims();
+
+// ../core/src/ops/runtime.ts
+init_cjs_shims();
 function cloneStyleMap(sm) {
   const blocks = /* @__PURE__ */ new Map();
   for (const [key, block] of sm.blocks) {
@@ -573,6 +575,32 @@ function removeSubtree(state, id) {
   state.doc.nodes.delete(id);
   state.removed.add(id);
 }
+function precond(op, nodeId, message) {
+  return diag("DF_OP_PRECONDITION_FAILED", message, {
+    nodeId,
+    pattern: op.origin.pattern,
+    severity: "error"
+  });
+}
+function primaryTarget(op) {
+  switch (op.op) {
+    case "removeNode":
+    case "unwrap":
+    case "replaceWith":
+    case "wrap":
+    case "moveNode":
+    case "setClassList":
+    case "mergeStyle":
+      return op.target;
+    case "insertBefore":
+    case "insertAfter":
+      return op.anchor;
+    case "mergeSiblings":
+      return op.first;
+    case "foldInheritedStyles":
+      return op.from;
+  }
+}
 function specToAttrs(map) {
   if (!map || map.size === 0) return { entries: /* @__PURE__ */ new Map(), spreads: [], order: [] };
   const entries = /* @__PURE__ */ new Map();
@@ -681,6 +709,9 @@ function mergeStyleMaps(target, source, policy) {
   }
   return { map: { blocks }, conflict };
 }
+
+// ../core/src/ops/apply.ts
+init_cjs_shims();
 function safetyOk(state, op, targetId) {
   const opSafety = op.origin.safety;
   if (opSafety > state.ceiling) {
@@ -907,32 +938,6 @@ function applyFold(state, op) {
   for (const d3 of issues) state.diagnostics.push(d3);
   return [];
 }
-function precond(op, nodeId, message) {
-  return diag("DF_OP_PRECONDITION_FAILED", message, {
-    nodeId,
-    pattern: op.origin.pattern,
-    severity: "error"
-  });
-}
-function primaryTarget(op) {
-  switch (op.op) {
-    case "removeNode":
-    case "unwrap":
-    case "replaceWith":
-    case "wrap":
-    case "moveNode":
-    case "setClassList":
-    case "mergeStyle":
-      return op.target;
-    case "insertBefore":
-    case "insertAfter":
-      return op.anchor;
-    case "mergeSiblings":
-      return op.first;
-    case "foldInheritedStyles":
-      return op.from;
-  }
-}
 function applyOps(doc, ops, ctx) {
   const cloned = cloneDocument(doc);
   const state = {
@@ -974,13 +979,9 @@ function finalize(state) {
 
 // ../core/src/pass-manager.ts
 init_cjs_shims();
-var DEFAULT_FIXPOINT = {
-  maxIterations: 16,
-  phases: { flatten: 16, compress: 8, extract: 4 },
-  onBudgetExhausted: "warn",
-  detectOscillation: true
-};
-var PHASE_ORDER = ["flatten", "compress", "extract"];
+
+// ../core/src/pass-context.ts
+init_cjs_shims();
 function createNullSelectorIndex() {
   const none = /* @__PURE__ */ new Set();
   return {
@@ -1190,10 +1191,137 @@ function buildMatchContext(doc, elementId, resolver, selectors, safety, phase, i
     }
   };
 }
-function stampOrigin(draft, pattern2) {
+
+// ../core/src/flatten-safety.ts
+init_cjs_shims();
+var DISPLAY = "display";
+var POSITION = "position";
+var TRANSFORM = "transform";
+var CONTEXT_SAFE_DISPLAYS = /* @__PURE__ */ new Set(["block", "contents", ""]);
+var STATIC_POSITIONS = /* @__PURE__ */ new Set(["static", ""]);
+var SELF_ALIGN_PROPS = [
+  "place-self",
+  "align-self",
+  "justify-self"
+];
+var NEUTRAL_ALIGN = /* @__PURE__ */ new Set(["auto", "normal", "auto auto", ""]);
+var FLEX_GRID_DISPLAYS = /* @__PURE__ */ new Set(["flex", "inline-flex", "grid", "inline-grid"]);
+function establishesChildContext(sm) {
+  for (const block of sm.blocks.values()) {
+    const display = block.decls.get(DISPLAY);
+    if (display && !CONTEXT_SAFE_DISPLAYS.has(String(display.value))) return true;
+    const position = block.decls.get(POSITION);
+    if (position && !STATIC_POSITIONS.has(String(position.value))) return true;
+    const transform = block.decls.get(TRANSFORM);
+    if (transform && String(transform.value) !== "none") return true;
+  }
+  return false;
+}
+function isInherited2(decl, norm) {
+  if (decl.inherited) return true;
+  try {
+    return norm.inherited.isInherited(decl.property);
+  } catch {
+    return false;
+  }
+}
+function childReproduces(childComputed, conditionK, prop, value) {
+  if (!childComputed) return false;
+  const block = childComputed.blocks.get(conditionK);
+  if (!block) return false;
+  const d3 = block.decls.get(prop);
+  return d3 != null && String(d3.value) === value;
+}
+function dropsOwnStyle(wrapperComputed, childComputed, norm) {
+  for (const block of wrapperComputed.blocks.values()) {
+    const ck = conditionKey(block.condition);
+    for (const [prop, decl] of block.decls) {
+      if (prop === DISPLAY || prop === POSITION || prop === TRANSFORM) continue;
+      if (isInherited2(decl, norm)) continue;
+      if (!childReproduces(childComputed, ck, prop, String(decl.value))) return true;
+    }
+  }
+  return false;
+}
+function displayOf(el, norm) {
+  if (!el) return "";
+  for (const block of norm.normalizeStyleMap(el.computed).blocks.values()) {
+    if (block.condition.media === "" && block.condition.states.length === 0 && block.condition.pseudoElement === "") {
+      const d3 = block.decls.get(DISPLAY);
+      if (d3) return String(d3.value);
+    }
+  }
+  return "";
+}
+function newParentIsFlexOrGrid(before, wrapper, norm) {
+  if (wrapper.parent == null) return false;
+  const p2 = before.nodes.get(wrapper.parent);
+  if (!p2 || p2.kind !== "element") return false;
+  return FLEX_GRID_DISPLAYS.has(displayOf(p2, norm));
+}
+function addsParentContextStyle(childBefore, childAfter, norm) {
+  if (!childAfter) return false;
+  const before = childBefore ? norm.normalizeStyleMap(childBefore) : null;
+  const after = norm.normalizeStyleMap(childAfter);
+  for (const block of after.blocks.values()) {
+    const ck = conditionKey(block.condition);
+    for (const prop of SELF_ALIGN_PROPS) {
+      const d3 = block.decls.get(prop);
+      if (!d3 || NEUTRAL_ALIGN.has(String(d3.value))) continue;
+      const prev = before?.blocks.get(ck)?.decls.get(prop);
+      if (!prev || String(prev.value) !== String(d3.value)) return true;
+    }
+  }
+  return false;
+}
+function unwrapTargetOf(ops) {
+  for (const op of ops) if (op.op === "unwrap") return op.target;
+  return null;
+}
+function survivingChildOf(ops, wrapper, before) {
+  for (const op of ops) if (op.op === "mergeStyle") return op.target;
+  for (const op of ops) if (op.op === "foldInheritedStyles" && op.into.length > 0) return op.into[0];
+  for (const c of wrapper.children) {
+    const n = before.nodes.get(c);
+    if (n && n.kind === "element") return c;
+  }
+  return null;
+}
+function classifyFlattenOps(before, after, ops, norm) {
+  const wrapperId = unwrapTargetOf(ops);
+  if (wrapperId == null) return { kind: "provably-safe", wrapperId: null, childId: null };
+  const wrapper = before.nodes.get(wrapperId);
+  if (!wrapper || wrapper.kind !== "element") {
+    return { kind: "provably-safe", wrapperId: null, childId: null };
+  }
+  const childId = survivingChildOf(ops, wrapper, before);
+  const wrapperComputed = norm.normalizeStyleMap(wrapper.computed);
+  const childAfter = childId != null ? getElement(after, childId)?.computed ?? null : null;
+  const childBefore = childId != null ? getElement(before, childId)?.computed ?? null : null;
+  if (establishesChildContext(wrapperComputed)) {
+    return { kind: "needs-verification", wrapperId, childId };
+  }
+  if (dropsOwnStyle(wrapperComputed, childAfter ? norm.normalizeStyleMap(childAfter) : null, norm)) {
+    return { kind: "needs-verification", wrapperId, childId };
+  }
+  if (addsParentContextStyle(childBefore, childAfter, norm) && !newParentIsFlexOrGrid(before, wrapper, norm)) {
+    return { kind: "needs-verification", wrapperId, childId };
+  }
+  return { kind: "provably-safe", wrapperId, childId };
+}
+
+// ../core/src/pass-manager.ts
+var DEFAULT_FIXPOINT = {
+  maxIterations: 16,
+  phases: { flatten: 16, compress: 8, extract: 4 },
+  onBudgetExhausted: "warn",
+  detectOscillation: true
+};
+var PHASE_ORDER = ["flatten", "compress", "extract"];
+function stampOrigin(draft, pattern) {
   return {
     ...draft,
-    origin: { pattern: pattern2.name, category: pattern2.category, safety: pattern2.safety }
+    origin: { pattern: pattern.name, category: pattern.category, safety: pattern.safety }
   };
 }
 function patternsForPhase(passes, phase) {
@@ -1245,69 +1373,76 @@ function flattenWouldDropStyle(before, after, ops, resolver, normalizer2) {
   }
   return false;
 }
+function flattenVerdict(before, after, ops, ctx) {
+  if (flattenWouldDropStyle(before, after, ops, ctx.resolver, ctx.normalizer)) return "revert";
+  const gate = ctx.gate ?? "all";
+  if (gate === "all") return "commit";
+  const cls = classifyFlattenOps(before, after, ops, ctx.normalizer);
+  return cls.kind === "provably-safe" ? "commit" : "revert";
+}
+function evaluateElement(doc, elId, patterns, ctx, factory, phase, iteration, diagnostics) {
+  for (const pattern of patterns) {
+    if (pattern.safety > ctx.safetyCeiling) continue;
+    let drafts = [];
+    try {
+      const mctx = buildMatchContext(doc, elId, ctx.resolver, ctx.selectors, ctx.safetyCeiling, phase, iteration);
+      const result = pattern.evaluate(mctx, factory);
+      if (!result) continue;
+      drafts = result.ops;
+      if (result.diagnostics) for (const d3 of result.diagnostics) diagnostics.push(d3);
+    } catch (err) {
+      diagnostics.push({
+        code: "DF_PATTERN_THREW",
+        severity: "error",
+        message: `pattern '${pattern.name}' threw: ${String(err?.message ?? err)}`,
+        nodeId: elId,
+        pattern: pattern.name,
+        phase,
+        iteration,
+        cause: err
+      });
+      continue;
+    }
+    if (drafts.length === 0) continue;
+    return { ops: drafts.map((d3) => stampOrigin(d3, pattern)), pattern };
+  }
+  return null;
+}
+function revertDiagnostic(pattern, elId, phase, iteration, resolverId) {
+  return {
+    code: "DF_VERIFY_REVERTED",
+    severity: "warn",
+    message: `flatten '${pattern.name}' reverted on node ${elId}: it would change rendering (drops a style, establishes layout context, or assumes a parent context) and was not proven safe by resolver '${resolverId}'`,
+    nodeId: elId,
+    pattern: pattern.name,
+    phase,
+    iteration
+  };
+}
 function runSweep(state, patterns, ctx, factory, phase, iteration, touched, diagnostics, flattenBarred) {
   let appliedOps = 0;
-  const resolver = ctx.resolver;
-  const selectors = ctx.selectors;
   for (const elId of elementIds(state.doc)) {
     const el = getElement(state.doc, elId);
     if (!el) continue;
     if (phase === "flatten" && flattenBarred.has(elId)) continue;
-    for (const pattern2 of patterns) {
-      if (pattern2.safety > ctx.safetyCeiling) continue;
-      let drafts = [];
-      try {
-        const mctx = buildMatchContext(
-          state.doc,
-          elId,
-          resolver,
-          selectors,
-          ctx.safetyCeiling,
-          phase,
-          iteration
-        );
-        const result = pattern2.evaluate(mctx, factory);
-        if (!result) continue;
-        drafts = result.ops;
-        if (result.diagnostics) for (const d3 of result.diagnostics) diagnostics.push(d3);
-      } catch (err) {
-        diagnostics.push({
-          code: "DF_PATTERN_THREW",
-          severity: "error",
-          message: `pattern '${pattern2.name}' threw: ${String(err?.message ?? err)}`,
-          nodeId: elId,
-          pattern: pattern2.name,
-          phase,
-          iteration,
-          cause: err
-        });
+    const evaluated = evaluateElement(state.doc, elId, patterns, ctx, factory, phase, iteration, diagnostics);
+    if (!evaluated) continue;
+    const { ops, pattern } = evaluated;
+    const outcome = applyOps(state.doc, ops, ctx);
+    for (const d3 of outcome.result.diagnostics) diagnostics.push(d3);
+    if (outcome.result.appliedGroups === 0) continue;
+    if (phase === "flatten") {
+      const verdict = flattenVerdict(state.doc, outcome.doc, ops, ctx);
+      if (verdict !== "commit") {
+        diagnostics.push(revertDiagnostic(pattern, elId, phase, iteration, ctx.resolver.id));
+        flattenBarred.add(elId);
         continue;
       }
-      if (drafts.length === 0) continue;
-      const ops = drafts.map((d3) => stampOrigin(d3, pattern2));
-      const outcome = applyOps(state.doc, ops, ctx);
-      for (const d3 of outcome.result.diagnostics) diagnostics.push(d3);
-      if (outcome.result.appliedGroups > 0) {
-        if (phase === "flatten" && flattenWouldDropStyle(state.doc, outcome.doc, ops, resolver, ctx.normalizer)) {
-          diagnostics.push({
-            code: "DF_VERIFY_REVERTED",
-            severity: "warn",
-            message: `flatten '${pattern2.name}' reverted on node ${elId}: residual style is not reproducible by resolver '${resolver.id}', so flattening would drop it`,
-            nodeId: elId,
-            pattern: pattern2.name,
-            phase,
-            iteration
-          });
-          flattenBarred.add(elId);
-          break;
-        }
-        state.doc = outcome.doc;
-        appliedOps += outcome.result.appliedGroups;
-        for (const id of outcome.result.touched) touched.add(id);
-        for (const id of outcome.result.created) touched.add(id);
-        break;
-      }
     }
+    state.doc = outcome.doc;
+    appliedOps += outcome.result.appliedGroups;
+    for (const id of outcome.result.touched) touched.add(id);
+    for (const id of outcome.result.created) touched.add(id);
   }
   return appliedOps;
 }
@@ -1322,6 +1457,26 @@ function docFingerprint(doc) {
   visit(doc.root);
   return parts.join("|");
 }
+function finalizePhase(phase, s, budget, onBudgetExhausted) {
+  if (!s.converged && s.haltReason !== "oscillation") {
+    s.haltReason = "budget";
+    s.diagnostics.push({
+      code: "DF_FIXPOINT_BUDGET",
+      severity: onBudgetExhausted === "error" ? "error" : "warn",
+      message: `phase '${phase}' exhausted ${budget}-iteration budget`,
+      phase,
+      iteration: s.iterations
+    });
+  }
+  return {
+    phase,
+    iterations: s.iterations,
+    converged: s.converged,
+    haltReason: s.haltReason,
+    touched: s.touched,
+    diagnostics: s.diagnostics
+  };
+}
 function runPasses(doc, passes, ctx, config) {
   const cfg = { ...DEFAULT_FIXPOINT, ...config };
   const factory = createRewriteFactory();
@@ -1330,76 +1485,54 @@ function runPasses(doc, passes, ctx, config) {
   const flattenBarred = /* @__PURE__ */ new Set();
   for (const phase of PHASE_ORDER) {
     const patterns = patternsForPhase(passes, phase);
-    const phaseTouched = /* @__PURE__ */ new Set();
-    const diagnostics = [];
     const budget = cfg.phases[phase] ?? cfg.maxIterations;
-    let iterations = 0;
-    let converged = false;
-    let haltReason = "converged";
-    const seen = /* @__PURE__ */ new Set();
+    const s = {
+      iterations: 0,
+      converged: false,
+      haltReason: "converged",
+      touched: /* @__PURE__ */ new Set(),
+      diagnostics: [],
+      seen: /* @__PURE__ */ new Set()
+    };
     if (patterns.length === 0) {
-      results.push({
-        phase,
-        iterations: 0,
-        converged: true,
-        haltReason: "converged",
-        touched: phaseTouched,
-        diagnostics
-      });
+      s.converged = true;
+      results.push(finalizePhase(phase, s, budget, cfg.onBudgetExhausted));
       continue;
     }
-    while (iterations < budget) {
-      iterations += 1;
+    while (s.iterations < budget) {
+      s.iterations += 1;
       const applied = runSweep(
         state,
         patterns,
         ctx,
         factory,
         phase,
-        iterations,
-        phaseTouched,
-        diagnostics,
+        s.iterations,
+        s.touched,
+        s.diagnostics,
         flattenBarred
       );
       if (applied === 0) {
-        converged = true;
-        haltReason = "converged";
+        s.converged = true;
         break;
       }
       if (cfg.detectOscillation) {
         const fp = docFingerprint(state.doc);
-        if (seen.has(fp)) {
-          haltReason = "oscillation";
-          diagnostics.push({
+        if (s.seen.has(fp)) {
+          s.haltReason = "oscillation";
+          s.diagnostics.push({
             code: "DF_FIXPOINT_OSCILLATION",
             severity: "warn",
             message: `phase '${phase}' oscillated; halting`,
             phase,
-            iteration: iterations
+            iteration: s.iterations
           });
           break;
         }
-        seen.add(fp);
+        s.seen.add(fp);
       }
     }
-    if (!converged && haltReason !== "oscillation") {
-      haltReason = "budget";
-      diagnostics.push({
-        code: "DF_FIXPOINT_BUDGET",
-        severity: cfg.onBudgetExhausted === "error" ? "error" : "warn",
-        message: `phase '${phase}' exhausted ${budget}-iteration budget`,
-        phase,
-        iteration: iterations
-      });
-    }
-    results.push({
-      phase,
-      iterations,
-      converged,
-      haltReason,
-      touched: phaseTouched,
-      diagnostics
-    });
+    results.push(finalizePhase(phase, s, budget, cfg.onBudgetExhausted));
   }
   return { doc: state.doc, results };
 }
@@ -1482,7 +1615,9 @@ init_cjs_shims();
 
 // ../frontend-jsx/src/frontend.ts
 init_cjs_shims();
-var import_parser = require("@babel/parser");
+
+// ../frontend-jsx/src/frontend-ast.ts
+init_cjs_shims();
 var import_traverse = __toESM(require("@babel/traverse"), 1);
 var traverse = typeof import_traverse.default === "function" ? import_traverse.default : import_traverse.default.default;
 var JSX_LANGS = ["jsx", "tsx"];
@@ -1546,10 +1681,71 @@ function classFormOf(node) {
       return "call";
   }
 }
+function findNestedJsxRoots(root) {
+  const out = [];
+  const seen = /* @__PURE__ */ new Set();
+  const visit = (n) => {
+    if (!n || seen.has(n)) return;
+    seen.add(n);
+    switch (n.type) {
+      case "JSXElement":
+      case "JSXFragment":
+        out.push(n);
+        return;
+      case "ParenthesizedExpression":
+      case "TSNonNullExpression":
+      case "TSAsExpression":
+      case "TSSatisfiesExpression":
+      case "TSTypeAssertion":
+        visit(n.expression);
+        return;
+      case "LogicalExpression":
+        visit(n.left);
+        visit(n.right);
+        return;
+      case "ConditionalExpression":
+        visit(n.consequent);
+        visit(n.alternate);
+        return;
+      case "SequenceExpression":
+        for (const e2 of n.expressions) visit(e2);
+        return;
+      case "CallExpression":
+      case "OptionalCallExpression":
+        for (const a of n.arguments) visit(a);
+        return;
+      case "ArrowFunctionExpression":
+      case "FunctionExpression":
+        visit(n.body);
+        return;
+      case "BlockStatement":
+        for (const s of n.body) visit(s);
+        return;
+      case "ReturnStatement":
+        visit(n.argument);
+        return;
+      case "IfStatement":
+        visit(n.consequent);
+        visit(n.alternate);
+        return;
+      case "ArrayExpression":
+        for (const el of n.elements) visit(el);
+        return;
+      default:
+        return;
+    }
+  };
+  visit(root);
+  return out;
+}
 function looksLikeJsx(id, code) {
   if (/\.[jt]sx$/i.test(id)) return true;
   return /<\/?[A-Za-z][\w.-]*|<>/.test(code);
 }
+
+// ../frontend-jsx/src/frontend-parse.ts
+init_cjs_shims();
+var import_parser = require("@babel/parser");
 function doParse(code, ctx) {
   const diagnostics = [];
   const doc = createDocument("jsx");
@@ -1651,7 +1847,8 @@ function doParse(code, ctx) {
     }
     return { kind: "dynamic", expr: internExpr(v2, false), span: spanOf(v2) ?? void 0 };
   };
-  const buildChild = (node, parentId) => {
+  const buildNestedRoot = (jsx, parentId) => jsx.type === "JSXFragment" ? buildFragment(jsx, parentId) : buildElement(jsx, parentId);
+  const appendChild = (node, parentId, out) => {
     switch (node.type) {
       case "JSXText": {
         const id = doc.alloc.next();
@@ -1663,36 +1860,47 @@ function doParse(code, ctx) {
             collapsible: /^\s*$/.test(node.value)
           })
         );
-        return id;
+        out.push(id);
+        return;
       }
       case "JSXExpressionContainer": {
-        if (node.expression.type === "JSXEmptyExpression") return null;
+        const expr = node.expression;
+        if (expr.type === "JSXEmptyExpression") return;
+        if (expr.type === "JSXElement" || expr.type === "JSXFragment") {
+          out.push(buildNestedRoot(expr, parentId));
+          return;
+        }
         const id = doc.alloc.next();
-        const ref = internExpr(node.expression, false);
+        const ref = internExpr(expr, false);
         doc.nodes.set(id, createExpr(id, ref, { parent: parentId, span: spanOf(node) }));
-        return id;
+        out.push(id);
+        for (const jsx of findNestedJsxRoots(expr)) out.push(buildNestedRoot(jsx, parentId));
+        return;
       }
       case "JSXSpreadChild": {
         const id = doc.alloc.next();
         const ref = internExpr(node.expression, true);
         doc.nodes.set(id, createExpr(id, ref, { parent: parentId, span: spanOf(node) }));
-        return id;
+        out.push(id);
+        for (const jsx of findNestedJsxRoots(node.expression)) {
+          out.push(buildNestedRoot(jsx, parentId));
+        }
+        return;
       }
       case "JSXElement":
-        return buildElement(node, parentId);
+        out.push(buildElement(node, parentId));
+        return;
       case "JSXFragment":
-        return buildFragment(node, parentId);
+        out.push(buildFragment(node, parentId));
+        return;
       default:
-        return null;
+        return;
     }
   };
   const buildFragment = (node, parentId) => {
     const id = doc.alloc.next();
     const children = [];
-    for (const c of node.children) {
-      const cid = buildChild(c, id);
-      if (cid != null) children.push(cid);
-    }
+    for (const c of node.children) appendChild(c, id, children);
     doc.nodes.set(id, createFragment(id, { children, parent: parentId, span: spanOf(node) }));
     backref.set(id, {
       nodeId: id,
@@ -1735,10 +1943,7 @@ function doParse(code, ctx) {
     }
     const attrs = { entries, spreads, order };
     const children = [];
-    for (const c of node.children) {
-      const cid = buildChild(c, id);
-      if (cid != null) children.push(cid);
-    }
+    for (const c of node.children) appendChild(c, id, children);
     for (const cid of children) {
       const cn = doc.nodes.get(cid);
       if (cn && cn.kind === "expr") {
@@ -1797,13 +2002,13 @@ function doParse(code, ctx) {
   };
   const roots = [];
   traverse(ast, {
-    JSXElement(path6) {
-      roots.push(path6.node);
-      path6.skip();
+    JSXElement(path7) {
+      roots.push(path7.node);
+      path7.skip();
     },
-    JSXFragment(path6) {
-      roots.push(path6.node);
-      path6.skip();
+    JSXFragment(path7) {
+      roots.push(path7.node);
+      path7.skip();
     }
   });
   const rootFrag = doc.nodes.get(doc.root);
@@ -1813,6 +2018,8 @@ function doParse(code, ctx) {
   }
   return { doc, diagnostics };
 }
+
+// ../frontend-jsx/src/frontend.ts
 var jsxFrontend = {
   name: "babel-jsx",
   langs: JSX_LANGS,
@@ -1899,6 +2106,61 @@ function editClasses(ms, doc, sf, el) {
   ms.appendLeft(insertAt, ` className="${tokens.join(" ")}"`);
   return true;
 }
+function extractKeyAttr(openTag) {
+  const m2 = /(^|\s)key\s*=\s*/.exec(openTag);
+  if (!m2) return null;
+  const keyStart = m2.index + m2[1].length;
+  let i = m2.index + m2[0].length;
+  const ch = openTag[i];
+  if (ch === "{") {
+    let depth = 0;
+    for (; i < openTag.length; i += 1) {
+      const c = openTag[i];
+      if (c === "{") depth += 1;
+      else if (c === "}") {
+        depth -= 1;
+        if (depth === 0) {
+          i += 1;
+          break;
+        }
+      }
+    }
+  } else if (ch === '"' || ch === "'") {
+    const q2 = ch;
+    i += 1;
+    for (; i < openTag.length; i += 1) {
+      if (openTag[i] === q2) {
+        i += 1;
+        break;
+      }
+    }
+  } else {
+    for (; i < openTag.length; i += 1) {
+      if (/[\s>/]/.test(openTag[i])) break;
+    }
+  }
+  return openTag.slice(keyStart, i);
+}
+function transferKeyOnUnwrap(ms, doc, sf, region, kept) {
+  const open = region.openTagSpan;
+  if (!open || open.file !== sf.id) return;
+  const keyAttr = extractKeyAttr(sf.text.slice(open.start, open.end));
+  if (!keyAttr) return;
+  const inside = [];
+  for (const n of kept) {
+    if (n.kind !== "element" || !n.span || n.span.file !== sf.id) continue;
+    if (strictlyContains(region.span, n.span)) inside.push(n);
+  }
+  const maximal = inside.filter(
+    (n) => !inside.some((o2) => o2 !== n && o2.span && n.span && strictlyContains(o2.span, n.span))
+  );
+  if (maximal.length !== 1) return;
+  const child = maximal[0];
+  const childOpen = doc.backref.get(child.id)?.openTagSpan;
+  if (!childOpen || childOpen.file !== sf.id) return;
+  if (extractKeyAttr(sf.text.slice(childOpen.start, childOpen.end))) return;
+  ms.appendLeft(childOpen.start + 1 + child.tag.length, ` ${keyAttr}`);
+}
 function surgicalPrint(doc) {
   const sf = primarySource(doc);
   if (!sf) return null;
@@ -1920,6 +2182,7 @@ function surgicalPrint(doc) {
     const coveredByFull = fullRemovals.some((f) => f !== span && strictlyContains(f, span));
     if (coveredByFull) continue;
     if (r2.unwrapped) {
+      transferKeyOnUnwrap(ms, doc, sf, r2.backref, kept);
       const open = r2.backref.openTagSpan;
       const close = r2.backref.closeTagSpan;
       if (open && open.file === sf.id && open.end > open.start) ms.remove(open.start, open.end);
@@ -2022,40 +2285,6 @@ function createJsxBackend() {
 // ../pattern-kit/src/index.ts
 init_cjs_shims();
 
-// ../pattern-kit/src/define.ts
-init_cjs_shims();
-var PHASES = /* @__PURE__ */ new Set(["flatten", "compress", "extract"]);
-var SAFETY_LEVELS = /* @__PURE__ */ new Set([0, 1, 2, 3]);
-function fail(name, why) {
-  throw new Error(`definePattern(${name || "<anonymous>"}): ${why}`);
-}
-function definePattern(spec) {
-  if (spec == null || typeof spec !== "object") {
-    throw new Error("definePattern: spec must be an object");
-  }
-  const name = spec.name;
-  if (typeof name !== "string" || name.length === 0) {
-    fail(String(name), "name must be a non-empty string");
-  }
-  if (typeof spec.category !== "string" || !spec.category.includes("/")) {
-    fail(name, `category must be a "<phase>/<slug>" string (got ${JSON.stringify(spec.category)})`);
-  }
-  const phase = spec.category.split("/", 1)[0];
-  if (!PHASES.has(phase)) {
-    fail(name, `category phase must be one of flatten|compress|extract (got "${phase}")`);
-  }
-  if (!SAFETY_LEVELS.has(spec.safety)) {
-    fail(name, `safety must be 0|1|2|3 (got ${JSON.stringify(spec.safety)})`);
-  }
-  if (typeof spec.evaluate !== "function") {
-    fail(name, "evaluate must be a function");
-  }
-  if (spec.priority !== void 0 && !Number.isFinite(spec.priority)) {
-    fail(name, "priority must be a finite number when provided");
-  }
-  return Object.freeze({ ...spec });
-}
-
 // ../pattern-kit/src/combinators.ts
 init_cjs_shims();
 
@@ -2402,6 +2631,11 @@ var hasRef = (node) => asElement(node)?.meta.hasRef ?? false;
 var hasEventHandlers = (node) => asElement(node)?.meta.hasEventHandlers ?? false;
 var hasDynamicChildren = (node) => asElement(node)?.meta.hasDynamicChildren ?? false;
 var hasDynamicClasses = (node) => asElement(node)?.classes.hasDynamic ?? false;
+var opaque = (node, ctx) => {
+  const el = asElement(node);
+  if (!el) return false;
+  return ctx.isOpaque(el);
+};
 var targetedByCombinator = (node, ctx) => {
   const el = asElement(node);
   if (!el) return false;
@@ -2414,9 +2648,45 @@ init_cjs_shims();
 
 // ../pattern-kit/src/pattern.ts
 init_cjs_shims();
-function camelToKebab(key) {
-  if (key.startsWith("--")) return key;
-  return key.replace(/[A-Z]/g, (m2) => `-${m2.toLowerCase()}`);
+
+// ../pattern-kit/src/define.ts
+init_cjs_shims();
+var PHASES = /* @__PURE__ */ new Set(["flatten", "compress", "extract"]);
+var SAFETY_LEVELS = /* @__PURE__ */ new Set([0, 1, 2, 3]);
+function fail(name, why) {
+  throw new Error(`definePattern(${name || "<anonymous>"}): ${why}`);
+}
+function validatePattern(spec) {
+  if (spec == null || typeof spec !== "object") {
+    throw new Error("definePattern: spec must be an object");
+  }
+  const name = spec.name;
+  if (typeof name !== "string" || name.length === 0) {
+    fail(String(name), "name must be a non-empty string");
+  }
+  if (typeof spec.category !== "string" || !spec.category.includes("/")) {
+    fail(name, `category must be a "<phase>/<slug>" string (got ${JSON.stringify(spec.category)})`);
+  }
+  const phase = spec.category.split("/", 1)[0];
+  if (!PHASES.has(phase)) {
+    fail(name, `category phase must be one of flatten|compress|extract (got "${phase}")`);
+  }
+  if (!SAFETY_LEVELS.has(spec.safety)) {
+    fail(name, `safety must be 0|1|2|3 (got ${JSON.stringify(spec.safety)})`);
+  }
+  if (typeof spec.evaluate !== "function") {
+    fail(name, "evaluate must be a function");
+  }
+  if (spec.priority !== void 0 && !Number.isFinite(spec.priority)) {
+    fail(name, "priority must be a finite number when provided");
+  }
+  return Object.freeze({ ...spec });
+}
+
+// ../pattern-kit/src/pattern.ts
+function camelToKebab(key) {
+  if (key.startsWith("--")) return key;
+  return key.replace(/[A-Z]/g, (m2) => `-${m2.toLowerCase()}`);
 }
 function plainToStyleMap(style) {
   const decls = /* @__PURE__ */ new Map();
@@ -2450,8 +2720,20 @@ var FLATTEN_GUARDS = and(
   not(targetedByCombinator),
   not(affectsSelectorMatching)
 );
-function isFlattenCategory(category) {
-  return category.split("/", 1)[0] === "flatten";
+var COMPRESS_GUARDS = and(
+  not(hasDynamicClasses),
+  not(opaque),
+  not(targetedByCombinator)
+);
+function autoGuardsFor(category) {
+  switch (category.split("/", 1)[0]) {
+    case "flatten":
+      return FLATTEN_GUARDS;
+    case "compress":
+      return COMPRESS_GUARDS;
+    default:
+      return null;
+  }
 }
 function compileDeclarativeMatch(m2) {
   const parts = [isElement(m2.tag)];
@@ -2467,7 +2749,8 @@ function compileDeclarativeMatch(m2) {
 function compileMatch(match, category) {
   if (typeof match === "function") return match;
   const declarative = compileDeclarativeMatch(match ?? {});
-  const guarded = isFlattenCategory(category) ? and(declarative, FLATTEN_GUARDS) : declarative;
+  const guards = autoGuardsFor(category);
+  const guarded = guards ? and(declarative, guards) : declarative;
   return (node, ctx) => guarded(node, ctx);
 }
 function pruneShadowed(sm, drop) {
@@ -2524,7 +2807,7 @@ function compileRewrite(rewrite) {
   const onConflict = rewrite.onConflict ?? "abort";
   return (ctx, rw) => [rw.mergeStyle(ctx.node, null, style, onConflict)];
 }
-function pattern(config) {
+function definePattern(config) {
   const matchFn = compileMatch(config.match, config.category);
   const rewriteFn = compileRewrite(config.rewrite);
   const spec = {
@@ -2534,7 +2817,7 @@ function pattern(config) {
     priority: config.priority,
     precondition: config.precondition,
     doc: config.doc,
-    examples: config.examples,
+    test: config.test,
     evaluate(ctx, rw) {
       if (!matchFn(ctx.node, ctx)) return null;
       const ops = rewriteFn(ctx, rw);
@@ -2542,7 +2825,7 @@ function pattern(config) {
       return { ops };
     }
   };
-  return definePattern(spec);
+  return validatePattern(spec);
 }
 
 // ../patterns/src/index.ts
@@ -2551,38 +2834,103 @@ init_cjs_shims();
 // ../patterns/src/_registry.generated.ts
 init_cjs_shims();
 
-// ../patterns/src/flatten/empty-style-div.pattern.ts
+// ../patterns/src/library/flatten/display-contents-wrapper.pattern.ts
 init_cjs_shims();
 function asEl(node) {
   const n = node;
   return n.kind === "element" ? n : null;
 }
+function metaOf(node) {
+  return asEl(node)?.meta ?? null;
+}
+var declaresCustomProperties = (node) => metaOf(node)?.declaresCustomProperties ?? false;
+var hasSpreadAttrs = (node) => metaOf(node)?.hasSpreadAttrs ?? false;
+var isComponentNode = (node) => metaOf(node)?.isComponent ?? false;
+var hasOwnAttrs = (node) => {
+  const el = asEl(node);
+  if (!el) return false;
+  return el.attrs.entries.size > 0 || el.attrs.spreads.length > 0;
+};
+var targetedByStructuralPseudo = (node, ctx) => {
+  const el = asEl(node);
+  if (!el) return false;
+  if (el.meta.targetedByStructuralPseudo) return true;
+  return ctx.selectors.targetedByStructuralPseudo(el.id);
+};
+var displayContentsWrapper = definePattern({
+  name: "display-contents-wrapper",
+  category: "flatten/display-contents-wrapper",
+  safety: 2,
+  doc: {
+    title: "Flatten display:contents wrapper",
+    summary: "A div with display:contents (which generates no box) wrapping a single element child, with no own visual style, no attributes beyond an inert class, and no opacity barriers, is removed; its sole child is hoisted in its place.",
+    before: '<div style="display:contents"><Child/></div>',
+    after: "<Child/>",
+    safetyRationale: "A display:contents element generates no box at all, so its children already render as direct children of its parent; removing it is layout-identical. It paints nothing, establishes no formatting/stacking/box context, is no containing block, carries no ref/handlers/dynamic-children/html/spread/component identity, owns no targetable attrs / custom-property coupling, and is not a combinator/structural-pseudo subject; inheritable styles are folded onto the child before removal."
+  },
+  match: {
+    tag: "div",
+    style: { display: "contents" },
+    onlyChild: "element",
+    paintsNothing: true,
+    where: [
+      not(declaresCustomProperties),
+      not(hasOwnAttrs),
+      not(hasDynamicClasses),
+      not(hasSpreadAttrs),
+      not(isComponentNode),
+      not(targetedByStructuralPseudo)
+    ]
+  },
+  rewrite: { flattenInto: "child" },
+  test: {
+    cases: [
+      {
+        // `display:contents` generates no box, so removing it is provably layout-identical → the
+        // wrapper is flattened even under the conservative gate; the child is hoisted.
+        before: '<div className="contents"><a className="text-blue-500">Link</a></div>',
+        after: '<a className="text-blue-500">Link</a>'
+      }
+    ],
+    noMatch: [
+      // A ref pins the wrapper's element identity (a hard opacity barrier) → not a passthrough.
+      '<div className="contents" ref={rootRef}><a className="text-blue-500">Link</a></div>'
+    ]
+  }
+});
+
+// ../patterns/src/library/flatten/empty-style-div.pattern.ts
+init_cjs_shims();
+function asEl2(node) {
+  const n = node;
+  return n.kind === "element" ? n : null;
+}
 function metaFlag2(flag) {
-  return (node) => Boolean(asEl(node)?.meta[flag]);
+  return (node) => Boolean(asEl2(node)?.meta[flag]);
 }
 var establishesBox = metaFlag2("establishesBox");
 var establishesFormattingContext = metaFlag2("establishesFormattingContext");
 var establishesStackingContext = metaFlag2("establishesStackingContext");
 var isContainingBlock = metaFlag2("isContainingBlock");
-var declaresCustomProperties = metaFlag2("declaresCustomProperties");
-var targetedByStructuralPseudo = (node, ctx) => {
-  const el = asEl(node);
+var declaresCustomProperties2 = metaFlag2("declaresCustomProperties");
+var targetedByStructuralPseudo2 = (node, ctx) => {
+  const el = asEl2(node);
   if (!el) return false;
   if (el.meta.targetedByStructuralPseudo) return true;
   return ctx.selectors.targetedByStructuralPseudo(el.id);
 };
-var DISPLAY = "display";
+var DISPLAY2 = "display";
 var hasNonBlockDisplay = (node, ctx) => {
-  const el = asEl(node);
+  const el = asEl2(node);
   if (!el) return false;
   const sm = ctx.computedOf(el) ?? el.computed;
   for (const block of sm.blocks.values()) {
-    const decl = block.decls.get(DISPLAY);
+    const decl = block.decls.get(DISPLAY2);
     if (decl && String(decl.value) !== "block") return true;
   }
   return false;
 };
-var emptyStyleDiv = pattern({
+var emptyStyleDiv = definePattern({
   name: "empty-style-div",
   category: "flatten/empty-style-div",
   safety: 1,
@@ -2603,26 +2951,29 @@ var emptyStyleDiv = pattern({
       not(establishesFormattingContext),
       not(establishesStackingContext),
       not(isContainingBlock),
-      not(declaresCustomProperties),
-      not(targetedByStructuralPseudo)
+      not(declaresCustomProperties2),
+      not(targetedByStructuralPseudo2)
     ]
   },
   rewrite: { flattenInto: "child" },
-  examples: [
-    {
-      before: '<div><span className="bg-red-200">Hi</span></div>',
-      after: '<span className="bg-red-200">Hi</span>'
-    },
-    {
+  test: {
+    cases: [
+      {
+        // A layout-neutral, style-free block div is a provably-safe flatten → removed, child hoisted.
+        before: '<div><span className="bg-red-200">Hi</span></div>',
+        after: '<span className="bg-red-200">Hi</span>'
+      }
+    ],
+    noMatch: [
       // The wrapper paints its own background (own visual style) → not layout-neutral, kept.
-      noMatch: '<div className="bg-blue-500"><span className="bg-red-200">Hi</span></div>'
-    }
-  ]
+      '<div className="bg-blue-500"><span className="bg-red-200">Hi</span></div>'
+    ]
+  }
 });
 
-// ../patterns/src/flatten/flex-center-wrapper.pattern.ts
+// ../patterns/src/library/flatten/flex-center-wrapper.pattern.ts
 init_cjs_shims();
-var flexCenterWrapper = pattern({
+var flexCenterWrapper = definePattern({
   name: "flex-center-wrapper",
   category: "flatten/flex-center-wrapper",
   safety: 2,
@@ -2643,21 +2994,65 @@ var flexCenterWrapper = pattern({
     flattenInto: "child",
     childGains: { placeSelf: "center" }
   },
-  examples: [
-    {
-      // The wrapper is removed; the surviving child gains `place-self-center` (reverse-emitted
-      // from the folded computed style by the resolver).
-      before: '<div className="flex justify-center items-center"><div className="bg-red-200">Hello</div></div>',
-      after: '<div className="bg-red-200 place-self-center">Hello</div>'
-    },
-    {
-      // onClick is a hard opacity barrier → the wrapper is load-bearing, no flatten.
-      noMatch: '<div className="flex justify-center items-center" onClick={handleClick}><div className="bg-red-200">Hello</div></div>'
-    }
-  ]
+  // Collapsing a flex-centering wrapper to `place-self:center` on the child only stays centered when
+  // the child's NEW parent is flex/grid; moreover the wrapper's own `display:flex` establishes a
+  // formatting context. Both make this a `needs-verification` flatten, which the conservative
+  // production gate (`'provably-safe'`, used by the harness) intentionally REVERTS — so every case
+  // here is a no-match: the wrapper is preserved. Op-level rewrite correctness (purity, id-preserving
+  // unwrap, opacity-barrier safety) is still asserted by the invariant suite over every pattern.
+  test: {
+    noMatch: [
+      // Even under a static flex/grid parent the centering flatten is not provably layout-neutral
+      // (the wrapper itself establishes a flex formatting context) → left unchanged.
+      '<div className="grid"><div className="flex items-center justify-center"><span className="bg-red-200">x</span></div></div>',
+      // Non-flex/grid parent (document root): place-self centering would not hold → left unchanged.
+      '<div className="flex justify-center items-center"><div className="bg-red-200">Hello</div></div>',
+      // onClick is a hard opacity barrier → the wrapper is load-bearing regardless of the gate.
+      '<div className="flex justify-center items-center" onClick={handleClick}><div className="bg-red-200">Hello</div></div>'
+    ]
+  }
+});
+
+// ../patterns/src/library/flatten/inline-flex-center-wrapper.pattern.ts
+init_cjs_shims();
+var inlineFlexCenterWrapper = definePattern({
+  name: "inline-flex-center-wrapper",
+  category: "flatten/inline-flex-center-wrapper",
+  safety: 2,
+  doc: {
+    title: "Flatten inline-flex-centering wrapper",
+    summary: "A div that only centers a single child (display:inline-flex; align-items:center; justify-content:center) is removed; the child gains place-self:center.",
+    before: '<div style="display:inline-flex;align-items:center;justify-content:center"><Child/></div>',
+    after: '<Child style="place-self:center"/>',
+    safetyRationale: "Wrapper paints nothing, carries no ref/handlers/dynamic children, and is not a combinator subject; inheritable styles are folded onto the child before removal."
+  },
+  match: {
+    tag: "div",
+    style: { display: "inline-flex", alignItems: "center", justifyContent: "center" },
+    onlyChild: "element",
+    paintsNothing: true
+  },
+  rewrite: {
+    flattenInto: "child",
+    childGains: { placeSelf: "center" }
+  },
+  // Like its block-level sibling, this centering flatten is `needs-verification` (the wrapper's own
+  // `display:inline-flex` establishes a formatting context, and place-self centering only holds under
+  // a flex/grid parent), so the conservative production gate (`'provably-safe'`) REVERTS it — every
+  // case here is a no-match. Op-level correctness is covered by the invariant suite.
+  test: {
+    noMatch: [
+      // Even under a static flex/grid parent the centering flatten is not provably layout-neutral.
+      '<div className="grid"><div className="inline-flex items-center justify-center"><span className="bg-red-200">x</span></div></div>',
+      // Non-flex/grid parent (document root) → left unchanged.
+      '<div className="inline-flex justify-center items-center"><div className="bg-red-200">Hello</div></div>',
+      // onClick is a hard opacity barrier → the wrapper is load-bearing regardless of the gate.
+      '<div className="inline-flex justify-center items-center" onClick={handleClick}><div className="bg-red-200">Hello</div></div>'
+    ]
+  }
 });
 
-// ../patterns/src/flatten/nested-flex-merge.pattern.ts
+// ../patterns/src/library/flatten/nested-flex-merge.pattern.ts
 init_cjs_shims();
 function baseConditionStyleMap(decls) {
   const map = /* @__PURE__ */ new Map();
@@ -2724,7 +3119,7 @@ var isInnerFlex = and(
   computed(DISPLAY_FLEX),
   not(targetedByCombinator)
 );
-var nestedFlexMerge = pattern({
+var nestedFlexMerge = definePattern({
   name: "nested-flex-merge",
   category: "flatten/nested-flex-merge",
   safety: 2,
@@ -2760,24 +3155,148 @@ var nestedFlexMerge = pattern({
       rw.unwrap(outer)
     ];
   },
-  examples: [
-    {
-      // The wrapper's flex declarations (align-items / gap) merge onto the inner flex container,
-      // then the wrapper is removed (its own `data-x` here just blocks the more aggressive
-      // passthrough-wrapper so this merge is the one that fires).
-      before: '<div className="flex items-center gap-2" data-x="1"><div className="flex flex-col">X</div></div>',
-      after: '<div className="flex flex-col gap-2 items-center">X</div>'
-    },
-    {
-      // A non-flex wrapper does not match the flex-container signature → left unchanged.
-      noMatch: '<div className="block bg-blue-500"><div className="flex flex-col">X</div></div>'
+  // Merging the outer flex container into the inner removes the outer's box, but a `display:flex`
+  // wrapper establishes a formatting context, so this is a `needs-verification` flatten that the
+  // conservative production gate (`'provably-safe'`) REVERTS — every case here is a no-match. The
+  // merge's op-level correctness (purity, id-preserving unwrap, opacity-barrier safety) is asserted
+  // by the invariant suite over every pattern.
+  test: {
+    noMatch: [
+      // The merge is real but not provably layout-neutral (the wrapper establishes a flex context),
+      // so under the conservative gate the nested containers are left in place.
+      '<div className="flex items-center gap-2" data-x="1"><div className="flex flex-col">X</div></div>',
+      // A non-flex wrapper does not match the flex-container signature → left unchanged anyway.
+      '<div className="block bg-blue-500"><div className="flex flex-col">X</div></div>'
+    ]
+  }
+});
+
+// ../patterns/src/library/flatten/nested-grid-merge.pattern.ts
+init_cjs_shims();
+function baseConditionStyleMap2(decls) {
+  const map = /* @__PURE__ */ new Map();
+  for (const [prop, value] of decls) {
+    for (const decl of normalizer.normalizeDeclaration(prop, value, false)) {
+      map.set(decl.property, decl);
     }
-  ]
+  }
+  const block = { condition: BASE_CONDITION, decls: map };
+  const blocks = /* @__PURE__ */ new Map([[conditionKey(BASE_CONDITION), block]]);
+  return { blocks };
+}
+var DISPLAY_GRID = baseConditionStyleMap2([["display", "grid"]]);
+var GRID_CONTAINER_PROPERTIES = /* @__PURE__ */ new Set([
+  "display",
+  "grid-template-columns",
+  "grid-template-rows",
+  "grid-template-areas",
+  "grid-auto-columns",
+  "grid-auto-rows",
+  "grid-auto-flow",
+  "justify-content",
+  "align-content",
+  "place-content",
+  "justify-items",
+  "align-items",
+  "place-items",
+  "row-gap",
+  "column-gap"
+]);
+function outerMergeSafe2(sm) {
+  const norm = normalizer.normalizeStyleMap(sm);
+  for (const block of norm.blocks.values()) {
+    for (const decl of block.decls.values()) {
+      if (GRID_CONTAINER_PROPERTIES.has(String(decl.property))) continue;
+      if (decl.inherited) continue;
+      return false;
+    }
+  }
+  return true;
+}
+function gridConflict(outer, inner) {
+  const a = normalizer.normalizeStyleMap(outer);
+  const b3 = normalizer.normalizeStyleMap(inner);
+  for (const [key, blockA] of a.blocks) {
+    const blockB = b3.blocks.get(key);
+    if (!blockB) continue;
+    for (const [prop, declA] of blockA.decls) {
+      if (!GRID_CONTAINER_PROPERTIES.has(String(prop))) continue;
+      const declB = blockB.decls.get(prop);
+      if (declB && declB.value !== declA.value) return true;
+    }
+  }
+  return false;
+}
+function extractGridStyle(sm) {
+  const blocks = /* @__PURE__ */ new Map();
+  for (const [key, block] of sm.blocks) {
+    const decls = /* @__PURE__ */ new Map();
+    for (const [prop, decl] of block.decls) {
+      if (GRID_CONTAINER_PROPERTIES.has(String(prop))) decls.set(prop, decl);
+    }
+    if (decls.size > 0) blocks.set(key, { condition: block.condition, decls });
+  }
+  return { blocks };
+}
+var isInnerGrid = and(
+  isElement("div"),
+  computed(DISPLAY_GRID),
+  not(targetedByCombinator)
+);
+var nestedGridMerge = definePattern({
+  name: "nested-grid-merge",
+  category: "flatten/nested-grid-merge",
+  safety: 2,
+  doc: {
+    title: "Merge nested grid containers",
+    summary: "A grid container whose only child is itself a grid container with non-conflicting grid properties is collapsed into one; the wrapper is removed and its grid declarations merge onto the surviving child.",
+    before: '<div style="display:grid;gap:8px"><div style="display:grid;grid-template-columns:1fr 1fr"/></div>',
+    after: '<div style="display:grid;grid-template-columns:1fr 1fr;gap:8px"/>',
+    safetyRationale: "The wrapper paints nothing, declares only grid-container/inheritable properties, carries no ref/handlers/dynamic children, and is not a combinator subject; the two containers do not conflict on any grid property, so the union is unambiguous and lossless."
+  },
+  match: {
+    tag: "div",
+    style: { display: "grid" },
+    onlyChild: "element",
+    paintsNothing: true
+  },
+  rewrite: (ctx, rw) => {
+    const outer = ctx.node;
+    const inner = ctx.onlyElementChild();
+    if (!inner) return null;
+    if (!isInnerGrid(inner, ctx)) return null;
+    const outerStyle = ctx.computed();
+    const innerStyle = ctx.computedOf(inner);
+    if (!outerMergeSafe2(outerStyle)) return null;
+    if (gridConflict(outerStyle, innerStyle)) return null;
+    return [
+      // 1. Preserve inheritable values (color/font/…) by folding them onto the child first.
+      rw.foldInheritedStyles(outer, inner, { conditions: "all" }),
+      // 2. Transfer the wrapper's grid-container declarations onto the child (target-wins keeps the
+      //    child's value for any shared property — identical anyway, we proved non-conflict).
+      rw.mergeStyle(inner, null, extractGridStyle(outerStyle), "target-wins"),
+      // 3. Remove the wrapper (structural-safe; hoists the child and preserves its IRNodeId).
+      rw.unwrap(outer)
+    ];
+  },
+  // Like its flex sibling, this merge removes the outer container's box, but a `display:grid` wrapper
+  // establishes a formatting context, so it is a `needs-verification` flatten that the conservative
+  // production gate (`'provably-safe'`) REVERTS — every case here is a no-match. Op-level correctness
+  // is asserted by the invariant suite over every pattern.
+  test: {
+    noMatch: [
+      // The merge is real but not provably layout-neutral (the wrapper establishes a grid context),
+      // so under the conservative gate the nested containers are left in place.
+      '<div className="grid gap-2" data-x="1"><div className="grid grid-cols-2">X</div></div>',
+      // A non-grid wrapper does not match the grid-container signature → left unchanged anyway.
+      '<div className="block bg-blue-500"><div className="grid grid-cols-2">X</div></div>'
+    ]
+  }
 });
 
-// ../patterns/src/flatten/passthrough-wrapper.pattern.ts
+// ../patterns/src/library/flatten/passthrough-wrapper.pattern.ts
 init_cjs_shims();
-function metaOf(node) {
+function metaOf2(node) {
   const n = node;
   return n.kind === "element" ? n.meta : null;
 }
@@ -2786,24 +3305,24 @@ function elementOf(node) {
   return n.kind === "element" ? n : null;
 }
 var establishesContext = (node) => {
-  const m2 = metaOf(node);
+  const m2 = metaOf2(node);
   if (!m2) return false;
   return m2.establishesBox || m2.establishesFormattingContext || m2.establishesStackingContext || m2.isContainingBlock || m2.declaresCustomProperties;
 };
-var hasSpreadAttrs = (node) => metaOf(node)?.hasSpreadAttrs ?? false;
-var isComponentNode = (node) => metaOf(node)?.isComponent ?? false;
-var hasOwnAttrs = (node) => {
+var hasSpreadAttrs2 = (node) => metaOf2(node)?.hasSpreadAttrs ?? false;
+var isComponentNode2 = (node) => metaOf2(node)?.isComponent ?? false;
+var hasOwnAttrs2 = (node) => {
   const el = elementOf(node);
   if (!el) return false;
   return el.attrs.entries.size > 0 || el.attrs.spreads.length > 0;
 };
-var targetedByStructuralPseudo2 = (node, ctx) => {
+var targetedByStructuralPseudo3 = (node, ctx) => {
   const el = elementOf(node);
   if (!el) return false;
   if (el.meta.targetedByStructuralPseudo) return true;
   return ctx.selectors.targetedByStructuralPseudo(el.id);
 };
-var passthroughWrapper = pattern({
+var passthroughWrapper = definePattern({
   name: "passthrough-wrapper",
   category: "flatten/passthrough-wrapper",
   safety: 2,
@@ -2820,27 +3339,34 @@ var passthroughWrapper = pattern({
     paintsNothing: true,
     where: [
       not(establishesContext),
-      not(hasOwnAttrs),
+      not(hasOwnAttrs2),
       not(hasDynamicClasses),
-      not(hasSpreadAttrs),
-      not(isComponentNode),
-      not(targetedByStructuralPseudo2)
+      not(hasSpreadAttrs2),
+      not(isComponentNode2),
+      not(targetedByStructuralPseudo3)
     ]
   },
   rewrite: { flattenInto: "child" },
-  examples: [
-    {
-      before: '<div className="flex"><a className="bg-red-200">Link</a></div>',
-      after: '<a className="bg-red-200">Link</a>'
-    },
-    {
+  test: {
+    cases: [
+      {
+        // A plain, style-free wrapper paints nothing and establishes no context → a provably-safe
+        // flatten under the conservative gate: the wrapper is removed and its sole child hoisted.
+        before: '<div><a className="bg-red-200">Link</a></div>',
+        after: '<a className="bg-red-200">Link</a>'
+      }
+    ],
+    noMatch: [
       // A ref pins the wrapper's element identity (a hard opacity barrier) → not a passthrough.
-      noMatch: '<div ref={rootRef}><a className="bg-red-200">Link</a></div>'
-    }
-  ]
+      '<div ref={rootRef}><a className="bg-red-200">Link</a></div>',
+      // A `display:flex` wrapper establishes a formatting context, so removing its box is NOT
+      // provably layout-neutral → the conservative gate leaves it in place.
+      '<div className="flex"><a className="bg-red-200">Link</a></div>'
+    ]
+  }
 });
 
-// ../patterns/src/flatten/redundant-fragment.pattern.ts
+// ../patterns/src/library/flatten/redundant-fragment.pattern.ts
 init_cjs_shims();
 function parentIsRedundantFragment(node, ctx) {
   const el = node;
@@ -2863,7 +3389,7 @@ function parentIsRedundantFragment(node, ctx) {
   if (ctx.selectors.reparentImpact(fid).size > 0) return false;
   return true;
 }
-var redundantFragment = pattern({
+var redundantFragment = definePattern({
   name: "redundant-fragment",
   category: "flatten/redundant-fragment",
   safety: 1,
@@ -2882,61 +3408,314 @@ var redundantFragment = pattern({
     if (!fragment || fragment.kind !== "fragment") return null;
     return [rw.unwrap(fragment)];
   },
-  examples: [
-    {
-      before: '<><span className="bg-red-200">Hi</span></>',
-      after: '<span className="bg-red-200">Hi</span>'
-    },
-    {
+  test: {
+    cases: [
+      {
+        // A fragment renders no box, so unwrapping a single-child fragment is always layout-identical
+        // → a provably-safe flatten: the child is spliced up into the fragment's slot.
+        before: '<><span className="bg-red-200">Hi</span></>',
+        after: '<span className="bg-red-200">Hi</span>'
+      }
+    ],
+    noMatch: [
       // Two children ⇒ not a single-child fragment, so the fragment is load-bearing and stays.
-      noMatch: '<><span className="bg-red-200">A</span><span className="bg-green-200">B</span></>'
-    }
-  ]
+      '<><span className="bg-red-200">A</span><span className="bg-green-200">B</span></>'
+    ]
+  }
 });
 
-// ../patterns/src/compress/dedupe-classes.pattern.ts
+// ../patterns/src/library/flatten/redundant-inline-wrapper.pattern.ts
 init_cjs_shims();
-function elementOf2(node) {
+function asEl3(node) {
   const n = node;
   return n.kind === "element" ? n : null;
 }
-var hasDangerousHtml = (node) => elementOf2(node)?.meta.hasDangerousHtml ?? false;
-var isOpaque = (node, ctx) => ctx.isOpaque(node);
-function findRedundantClasses(computed2) {
-  const winners = /* @__PURE__ */ new Set();
-  const shadowed = /* @__PURE__ */ new Set();
-  for (const block of computed2.blocks.values()) {
-    for (const decl of block.decls.values()) {
-      if (decl.origin && decl.origin.kind === "class") winners.add(decl.origin.className);
-      for (const o2 of decl.shadowed ?? []) {
-        if (o2.kind === "class") shadowed.add(o2.className);
-      }
-    }
-  }
-  return { winners, shadowed };
+function metaOf3(node) {
+  return asEl3(node)?.meta ?? null;
 }
-var dedupeClasses = pattern({
-  name: "dedupe-classes",
-  category: "compress/dedupe-classes",
-  safety: 1,
+var establishesContext2 = (node) => {
+  const m2 = metaOf3(node);
+  if (!m2) return false;
+  return m2.establishesBox || m2.establishesFormattingContext || m2.establishesStackingContext || m2.isContainingBlock || m2.declaresCustomProperties;
+};
+var hasSpreadAttrs3 = (node) => metaOf3(node)?.hasSpreadAttrs ?? false;
+var isComponentNode3 = (node) => metaOf3(node)?.isComponent ?? false;
+var hasOwnAttrs3 = (node) => {
+  const el = asEl3(node);
+  if (!el) return false;
+  return el.attrs.entries.size > 0 || el.attrs.spreads.length > 0;
+};
+var targetedByStructuralPseudo4 = (node, ctx) => {
+  const el = asEl3(node);
+  if (!el) return false;
+  if (el.meta.targetedByStructuralPseudo) return true;
+  return ctx.selectors.targetedByStructuralPseudo(el.id);
+};
+var DISPLAY3 = "display";
+var hasNonInlineDisplay = (node, ctx) => {
+  const el = asEl3(node);
+  if (!el) return false;
+  const sm = ctx.computedOf(el) ?? el.computed;
+  for (const block of sm.blocks.values()) {
+    const decl = block.decls.get(DISPLAY3);
+    if (decl && String(decl.value) !== "inline") return true;
+  }
+  return false;
+};
+var redundantInlineWrapper = definePattern({
+  name: "redundant-inline-wrapper",
+  category: "flatten/redundant-inline-wrapper",
+  safety: 2,
   doc: {
-    title: "Dedupe fully-overridden class tokens",
-    summary: "Drops class tokens whose every declaration is overridden by a later token resolving to the same property; the surviving token set produces a byte-for-byte identical computed style.",
-    before: '<p class="text-sm text-lg" />',
-    after: '<p class="text-lg" />',
-    safetyRationale: "A fully-overridden token contributes nothing to the computed style in any condition, so removing it changes no pixels. Dynamic/opaque class lists, ref/handler/dynamic-children/raw-html barriers, combinator subjects, and selector-bound (non-droppable) tokens are excluded."
+    title: "Flatten redundant inline wrapper",
+    summary: "An inline span with no own visual/box style, no attributes beyond an inert class, exactly one element child, and no opacity barriers is removed; its sole child is hoisted in its place.",
+    before: "<span><Child/></span>",
+    after: "<Child/>",
+    safetyRationale: "An empty inline box paints nothing and establishes no layout/paint/var context; with the inline default display and a single element child its removal changes no paint and no flow. The span carries no ref/handlers/dynamic-children/html/spread/component identity, owns no targetable attrs, and is not a combinator/structural-pseudo subject; inheritable styles are folded onto the child before removal."
   },
   match: {
+    tag: "span",
+    onlyChild: "element",
+    paintsNothing: true,
     where: [
-      not(hasRef),
-      not(hasEventHandlers),
-      not(hasDynamicChildren),
-      not(hasDangerousHtml),
+      not(hasNonInlineDisplay),
+      not(establishesContext2),
+      not(hasOwnAttrs3),
       not(hasDynamicClasses),
-      not(isOpaque),
-      not(targetedByCombinator)
+      not(hasSpreadAttrs3),
+      not(isComponentNode3),
+      not(targetedByStructuralPseudo4)
     ]
   },
+  rewrite: { flattenInto: "child" },
+  test: {
+    cases: [
+      {
+        // An empty inline span paints nothing and establishes no context → a provably-safe flatten:
+        // the span is removed and its sole child hoisted in place.
+        before: '<span><a className="text-blue-500">Link</a></span>',
+        after: '<a className="text-blue-500">Link</a>'
+      }
+    ],
+    noMatch: [
+      // A ref pins the span's element identity (a hard opacity barrier) → not a passthrough.
+      '<span ref={spanRef}><a className="text-blue-500">Link</a></span>',
+      // The span paints its own background (own visual style) → kept.
+      '<span className="bg-green-200"><a className="text-blue-500">Link</a></span>',
+      // Non-inline display (inline-block) participates in layout differently → kept.
+      '<span className="inline-block"><a className="text-blue-500">Link</a></span>'
+    ]
+  }
+});
+
+// ../patterns/src/library/compress/border-radius-shorthand.pattern.ts
+init_cjs_shims();
+var CORNERS = [
+  "border-top-left-radius",
+  "border-top-right-radius",
+  "border-bottom-right-radius",
+  "border-bottom-left-radius"
+];
+var CORNER_SET = new Set(CORNERS);
+var BASE_KEY = conditionKey(BASE_CONDITION);
+var RADIUS = "border-radius";
+var NON_COLLAPSIBLE_VALUES = /* @__PURE__ */ new Set([
+  "initial",
+  "inherit",
+  "unset",
+  "revert",
+  "revert-layer"
+]);
+function analyzeRadius(sm) {
+  const block = sm.blocks.get(BASE_KEY);
+  if (!block) return null;
+  const corners = [];
+  for (const corner of CORNERS) {
+    const decl = block.decls.get(corner);
+    if (!decl) return null;
+    corners.push(decl);
+  }
+  const important = corners[0].important;
+  if (!corners.every((d3) => d3.important === important)) return null;
+  const value = String(corners[0].value);
+  if (NON_COLLAPSIBLE_VALUES.has(value)) return null;
+  if (!corners.every((d3) => String(d3.value) === value)) return null;
+  const relative4 = corners.some((d3) => d3.relativeToParent);
+  return { value, important, relative: relative4 };
+}
+function withFoldedRadius(sm, fold) {
+  const blocks = /* @__PURE__ */ new Map();
+  for (const [key, block] of sm.blocks) {
+    if (key !== BASE_KEY) {
+      blocks.set(key, block);
+      continue;
+    }
+    const decls = /* @__PURE__ */ new Map();
+    for (const [prop, decl] of block.decls) {
+      if (CORNER_SET.has(String(prop))) continue;
+      decls.set(prop, decl);
+    }
+    const shorthand = {
+      property: RADIUS,
+      value: fold.value,
+      important: fold.important,
+      relativeToParent: fold.relative,
+      inherited: false
+      // border-radius is never inherited
+    };
+    decls.set(shorthand.property, shorthand);
+    blocks.set(key, { condition: block.condition, decls });
+  }
+  return { blocks };
+}
+var borderRadiusShorthand = definePattern({
+  name: "border-radius-shorthand",
+  category: "compress/border-radius-shorthand",
+  safety: 1,
+  doc: {
+    title: "Collapse equal corner radii into border-radius",
+    summary: "An element whose four corner radii (border-*-radius longhands) are all equal is rewritten to the single Tailwind rounded-* utility (border-radius === the four equal corners).",
+    before: '<div class="rounded-tl-lg rounded-tr-lg rounded-br-lg rounded-bl-lg"/>',
+    after: '<div class="rounded-lg"/>',
+    safetyRationale: "`border-radius` is value-identical to four equal corner radii \u2014 a class-only change. It is safe even on an element with a ref, event handler, dynamic child, or dangerouslySetInnerHTML \u2014 a className rewrite touches none of them; only a dynamic/opaque class list or a combinator-subject class is excluded, so no behaviour or project selector is disturbed."
+  },
+  rewrite: {
+    rewriteClasses(computed2) {
+      const fold = analyzeRadius(computed2);
+      return fold ? withFoldedRadius(computed2, fold) : null;
+    }
+  },
+  test: {
+    cases: [
+      {
+        // The four equal corner longhands collapse to a `border-radius` decl at the IR level; the
+        // minimizing reverse-emit then picks the single shortest utility (`rounded-lg`) that reproduces
+        // it, replacing the four `rounded-{tl,tr,br,bl}-lg` tokens. `bg-red-200` is preserved.
+        before: '<div className="rounded-tl-lg rounded-tr-lg rounded-br-lg rounded-bl-lg bg-red-200">box</div>',
+        after: '<div className="bg-red-200 rounded-lg">box</div>'
+      }
+    ],
+    // Corners differ (top corners vs bottom corners) → no all-equal collapse.
+    noMatch: ['<div className="rounded-t-lg rounded-b-sm bg-red-200">box</div>']
+  }
+});
+
+// ../patterns/src/library/compress/border-shorthand.pattern.ts
+init_cjs_shims();
+var WIDTH_SIDES = [
+  "border-top-width",
+  "border-right-width",
+  "border-bottom-width",
+  "border-left-width"
+];
+var WIDTH_SIDE_SET = new Set(WIDTH_SIDES);
+var BASE_KEY2 = conditionKey(BASE_CONDITION);
+var BORDER_WIDTH = "border-width";
+function analyzeWidth(sm) {
+  const block = sm.blocks.get(BASE_KEY2);
+  if (!block) return null;
+  const sides = [];
+  for (const side of WIDTH_SIDES) {
+    const decl = block.decls.get(side);
+    if (!decl) return null;
+    sides.push(decl);
+  }
+  const [top, right, bottom, left] = sides;
+  if (!(top.important === right.important && right.important === bottom.important && bottom.important === left.important)) {
+    return null;
+  }
+  const tv = String(top.value);
+  const rv = String(right.value);
+  const bv = String(bottom.value);
+  const lv = String(left.value);
+  if (tv !== bv || lv !== rv) return null;
+  const value = tv === lv ? tv : `${tv} ${lv}`;
+  const relative4 = sides.some((d3) => d3.relativeToParent);
+  return { value, important: top.important, relative: relative4 };
+}
+function withFoldedWidth(sm, fold) {
+  const blocks = /* @__PURE__ */ new Map();
+  for (const [key, block] of sm.blocks) {
+    if (key !== BASE_KEY2) {
+      blocks.set(key, block);
+      continue;
+    }
+    const decls = /* @__PURE__ */ new Map();
+    for (const [prop, decl] of block.decls) {
+      if (WIDTH_SIDE_SET.has(String(prop))) continue;
+      decls.set(prop, decl);
+    }
+    const shorthand = {
+      property: BORDER_WIDTH,
+      value: fold.value,
+      important: fold.important,
+      relativeToParent: fold.relative,
+      inherited: false
+      // border-width is never inherited
+    };
+    decls.set(shorthand.property, shorthand);
+    blocks.set(key, { condition: block.condition, decls });
+  }
+  return { blocks };
+}
+var borderShorthand = definePattern({
+  name: "border-shorthand",
+  category: "compress/border-shorthand",
+  safety: 1,
+  doc: {
+    title: "Collapse border-width longhands to shorthand",
+    summary: "Equal border width on all four sides (or matching x/y pairs) expressed as separate longhand declarations is collapsed to the shortest equivalent border-width shorthand (border-* / border-x-* border-y-*).",
+    before: '<div class="border-t-2 border-r-2 border-b-2 border-l-2"/>',
+    after: '<div class="border-2"/>',
+    safetyRationale: "A value-preserving re-serialization of the same computed border widths (style/color longhands untouched) \u2014 a class-only change. It is safe even on an element with a ref, event handler, dynamic child, or dangerouslySetInnerHTML \u2014 a className rewrite touches none of them; only a dynamic/opaque class list or a combinator-subject class is excluded, so no behaviour or project selector is disturbed."
+  },
+  rewrite: {
+    rewriteClasses(computed2) {
+      const fold = analyzeWidth(computed2);
+      return fold ? withFoldedWidth(computed2, fold) : null;
+    }
+  },
+  test: {
+    cases: [
+      {
+        // The four equal width longhands collapse to a `border-width` shorthand at the IR level, and the
+        // minimizing reverse-emit picks the single shortest utility (`border-2`) that reproduces it,
+        // replacing the four `border-{t,r,b,l}-2` tokens. `bg-red-200` is preserved.
+        before: '<div className="border-t-2 border-r-2 border-b-2 border-l-2 bg-red-200">box</div>',
+        after: '<div className="bg-red-200 border-2">box</div>'
+      }
+    ],
+    // Asymmetric widths (top != bottom) cannot fold into a shorthand.
+    noMatch: ['<div className="border-t-2 border-r-4 border-b-8 border-l-4 bg-red-200">box</div>']
+  }
+});
+
+// ../patterns/src/library/compress/dedupe-classes.pattern.ts
+init_cjs_shims();
+function findRedundantClasses(computed2) {
+  const winners = /* @__PURE__ */ new Set();
+  const shadowed = /* @__PURE__ */ new Set();
+  for (const block of computed2.blocks.values()) {
+    for (const decl of block.decls.values()) {
+      if (decl.origin && decl.origin.kind === "class") winners.add(decl.origin.className);
+      for (const o2 of decl.shadowed ?? []) {
+        if (o2.kind === "class") shadowed.add(o2.className);
+      }
+    }
+  }
+  return { winners, shadowed };
+}
+var dedupeClasses = definePattern({
+  name: "dedupe-classes",
+  category: "compress/dedupe-classes",
+  safety: 1,
+  doc: {
+    title: "Dedupe fully-overridden class tokens",
+    summary: "Drops class tokens whose every declaration is overridden by a later token resolving to the same property; the surviving token set produces a byte-for-byte identical computed style.",
+    before: '<p class="text-sm text-lg" />',
+    after: '<p class="text-lg" />',
+    safetyRationale: "A fully-overridden token contributes nothing to the computed style in any condition, so removing it changes no pixels \u2014 a class-only change. It is safe even on an element with a ref, event handler, dynamic child, or dangerouslySetInnerHTML \u2014 a className rewrite touches none of them; only a dynamic/opaque class list or a combinator-subject class is excluded, so no behaviour or project selector is disturbed."
+  },
   rewrite: {
     dropClasses(computed2, ctx) {
       const { winners, shadowed } = findRedundantClasses(computed2);
@@ -2949,22 +3728,91 @@ var dedupeClasses = pattern({
       return drop;
     }
   },
-  examples: [
-    {
-      // `text-sm` is fully overridden by `text-lg` (both set font-size + line-height). The resolver
-      // records that shadowing in provenance and reports the Tailwind utility as droppable, so the
-      // pattern drops `text-sm`; the reverse-emit then re-derives the minimal set (`text-lg`).
-      before: '<p className="text-sm text-lg">Hi</p>',
-      after: '<p className="text-lg">Hi</p>'
-    },
-    {
-      // Both tokens win a distinct property (no full override) → nothing to dedupe.
-      noMatch: '<p className="text-lg font-bold">Hi</p>'
+  test: {
+    cases: [
+      {
+        // `text-sm` is fully overridden by `text-lg` (both set font-size + line-height). The resolver
+        // records that shadowing in provenance and reports the Tailwind utility as droppable, so the
+        // pattern drops `text-sm`; the reverse-emit then re-derives the minimal set (`text-lg`).
+        before: '<p className="text-sm text-lg">Hi</p>',
+        after: '<p className="text-lg">Hi</p>'
+      }
+    ],
+    // Both tokens win a distinct property (no full override) → nothing to dedupe.
+    noMatch: ['<p className="text-lg font-bold">Hi</p>']
+  }
+});
+
+// ../patterns/src/library/compress/gap-shorthand.pattern.ts
+init_cjs_shims();
+var ROW_GAP = "row-gap";
+var COLUMN_GAP = "column-gap";
+var GAP = "gap";
+var BASE_KEY3 = conditionKey(BASE_CONDITION);
+function withGapShorthand(sm, gapDecl) {
+  const blocks = /* @__PURE__ */ new Map();
+  for (const [key, block] of sm.blocks) {
+    if (key !== BASE_KEY3) {
+      blocks.set(key, block);
+      continue;
     }
-  ]
+    const decls = /* @__PURE__ */ new Map();
+    for (const [prop, decl] of block.decls) {
+      if (prop === ROW_GAP || prop === COLUMN_GAP) continue;
+      decls.set(prop, decl);
+    }
+    decls.set(gapDecl.property, gapDecl);
+    blocks.set(key, { condition: block.condition, decls });
+  }
+  return { blocks };
+}
+var gapShorthand = definePattern({
+  name: "gap-shorthand",
+  category: "compress/gap-shorthand",
+  safety: 1,
+  doc: {
+    title: "Collapse equal row/column gap into the `gap` shorthand",
+    summary: "An element whose computed row-gap and column-gap are equal has the two axis longhands collapsed into a single-value `gap` shorthand (Tailwind gap-x-* gap-y-* \u2192 gap-*).",
+    before: '<div style="row-gap:16px;column-gap:16px"/>',
+    after: '<div style="gap:16px"/>',
+    safetyRationale: "A single-value `gap` is value-identical to an equal row-gap+column-gap pair \u2014 a class-only change. It is safe even on an element with a ref, event handler, dynamic child, or dangerouslySetInnerHTML \u2014 a className rewrite touches none of them; only a dynamic/opaque class list or a combinator-subject class is excluded, so no behaviour or project selector is disturbed."
+  },
+  rewrite: {
+    rewriteClasses(computed2) {
+      const base = computed2.blocks.get(BASE_KEY3);
+      if (!base) return null;
+      const rowGap = base.decls.get(ROW_GAP);
+      const colGap = base.decls.get(COLUMN_GAP);
+      if (!rowGap || !colGap) return null;
+      if (rowGap.important !== colGap.important) return null;
+      if (rowGap.value !== colGap.value) return null;
+      const gapDecl = {
+        property: GAP,
+        value: rowGap.value,
+        important: rowGap.important,
+        relativeToParent: rowGap.relativeToParent || colGap.relativeToParent,
+        inherited: false
+        // gap is not an inherited property
+      };
+      return withGapShorthand(computed2, gapDecl);
+    }
+  },
+  test: {
+    cases: [
+      {
+        // Equal row/column gap collapse to a `gap` decl at the IR level; the minimizing reverse-emit
+        // re-expands `gap` to row-gap+column-gap and picks the single utility covering both (`gap-4`),
+        // replacing the `gap-x-4`+`gap-y-4` pair. `bg-red-200` is preserved.
+        before: '<div className="gap-x-4 gap-y-4 bg-red-200">box</div>',
+        after: '<div className="bg-red-200 gap-4">box</div>'
+      }
+    ],
+    // Unequal axes (row-gap != column-gap) have no single-value `gap` equivalent → not collapsed.
+    noMatch: ['<div className="gap-x-2 gap-y-4 bg-red-200">box</div>']
+  }
 });
 
-// ../patterns/src/compress/inset-shorthand.pattern.ts
+// ../patterns/src/library/compress/inset-shorthand.pattern.ts
 init_cjs_shims();
 var TOP = "top";
 var RIGHT = "right";
@@ -2973,10 +3821,6 @@ var LEFT = "left";
 var INSET = "inset";
 var INSET_BLOCK = "inset-block";
 var INSET_INLINE = "inset-inline";
-var hasRawHtml2 = (node) => {
-  const n = node;
-  return n.kind === "element" ? n.meta.hasDangerousHtml : false;
-};
 function sameSide(a, b3) {
   return a !== void 0 && b3 !== void 0 && a.value === b3.value && a.important === b3.important;
 }
@@ -2991,7 +3835,7 @@ function withBaseDecls(src, baseDecls) {
   }
   return { blocks };
 }
-var insetShorthand = pattern({
+var insetShorthand = definePattern({
   name: "inset-shorthand",
   category: "compress/inset-shorthand",
   safety: 2,
@@ -3000,17 +3844,7 @@ var insetShorthand = pattern({
     summary: "top/right/bottom/left set to one value collapse to `inset`; a matching top/bottom or left/right pair collapses to `inset-block` / `inset-inline` (Tailwind inset-y / inset-x).",
     before: '<div style="top:10px;right:10px;bottom:10px;left:10px"/>',
     after: '<div style="inset:10px"/>',
-    safetyRationale: "Meaning-preserving shorthand compaction; the element is not a combinator subject and carries no ref/handlers/dynamic children/raw HTML, so neither selector matching nor behaviour changes."
-  },
-  match: {
-    where: [
-      not(hasRef),
-      not(hasEventHandlers),
-      not(hasDynamicChildren),
-      not(hasRawHtml2),
-      not(hasDynamicClasses),
-      not(targetedByCombinator)
-    ]
+    safetyRationale: "Meaning-preserving inset shorthand compaction \u2014 a class-only change. It is safe even on an element with a ref, event handler, dynamic child, or dangerouslySetInnerHTML \u2014 a className rewrite touches none of them; only a dynamic/opaque class list or a combinator-subject class is excluded, so no behaviour or project selector is disturbed."
   },
   rewrite: {
     rewriteClasses(computed2) {
@@ -3046,22 +3880,22 @@ var insetShorthand = pattern({
       return withBaseDecls(computed2, next);
     }
   },
-  examples: [
-    {
-      // The four equal inset longhands collapse to an `inset` shorthand at the IR level; the
-      // minimizing reverse-emit expands it back to top/right/bottom/left and picks the single utility
-      // covering all four (`inset-0`), replacing the four physical-side tokens. `bg-red-200` survives.
-      before: '<div className="top-0 right-0 bottom-0 left-0 bg-red-200">box</div>',
-      after: '<div className="bg-red-200 inset-0">box</div>'
-    },
-    {
-      // No matching inset pair (all four distinct) → nothing collapses.
-      noMatch: '<div className="top-0 right-1 bottom-2 left-3 bg-red-200">box</div>'
-    }
-  ]
+  test: {
+    cases: [
+      {
+        // The four equal inset longhands collapse to an `inset` shorthand at the IR level; the
+        // minimizing reverse-emit expands it back to top/right/bottom/left and picks the single utility
+        // covering all four (`inset-0`), replacing the four physical-side tokens. `bg-red-200` survives.
+        before: '<div className="top-0 right-0 bottom-0 left-0 bg-red-200">box</div>',
+        after: '<div className="bg-red-200 inset-0">box</div>'
+      }
+    ],
+    // No matching inset pair (all four distinct) → nothing collapses.
+    noMatch: ['<div className="top-0 right-1 bottom-2 left-3 bg-red-200">box</div>']
+  }
 });
 
-// ../patterns/src/compress/margin-shorthand.pattern.ts
+// ../patterns/src/library/compress/margin-shorthand.pattern.ts
 init_cjs_shims();
 var MARGIN_SIDES = [
   "margin-top",
@@ -3070,12 +3904,7 @@ var MARGIN_SIDES = [
   "margin-left"
 ];
 var MARGIN_SIDE_SET = new Set(MARGIN_SIDES);
-var BASE_KEY = conditionKey(BASE_CONDITION);
-function asElement3(node) {
-  const n = node;
-  return n.kind === "element" ? n : null;
-}
-var hasDangerousHtml2 = (node) => asElement3(node)?.meta.hasDangerousHtml ?? false;
+var BASE_KEY4 = conditionKey(BASE_CONDITION);
 function collapseMarginValue(top, right, bottom, left) {
   if (right === left) {
     if (top === bottom) {
@@ -3088,7 +3917,7 @@ function collapseMarginValue(top, right, bottom, left) {
 function withFoldedMargin(sm, marginDecl) {
   const blocks = /* @__PURE__ */ new Map();
   for (const [key, block] of sm.blocks) {
-    if (key !== BASE_KEY) {
+    if (key !== BASE_KEY4) {
       blocks.set(key, block);
       continue;
     }
@@ -3101,7 +3930,7 @@ function withFoldedMargin(sm, marginDecl) {
   }
   return { blocks };
 }
-var marginShorthand = pattern({
+var marginShorthand = definePattern({
   name: "margin-shorthand",
   category: "compress/margin-shorthand",
   safety: 2,
@@ -3110,177 +3939,567 @@ var marginShorthand = pattern({
     summary: "An element with margin-top/right/bottom/left all set has them collapsed into the shortest legal `margin` shorthand (the m / mx / my forms); meaning is preserved, declaration count drops.",
     before: '<div style="margin-top:8px;margin-right:8px;margin-bottom:8px;margin-left:8px"/>',
     after: '<div style="margin:8px"/>',
-    safetyRationale: "Pure representation change (no pixels move); skips nodes with ref/handlers/dynamic children/raw html, dynamic class segments, or combinator-subject selectors."
+    safetyRationale: "A pure representation change of the same computed margins (no pixels move) \u2014 a class-only change. It is safe even on an element with a ref, event handler, dynamic child, or dangerouslySetInnerHTML \u2014 a className rewrite touches none of them; only a dynamic/opaque class list or a combinator-subject class is excluded, so no behaviour or project selector is disturbed."
   },
-  match: {
-    where: [
-      not(hasRef),
-      not(hasEventHandlers),
-      not(hasDynamicChildren),
-      not(hasDynamicClasses),
-      not(hasDangerousHtml2),
-      not(targetedByCombinator)
-    ]
+  rewrite: {
+    rewriteClasses(computed2) {
+      const base = computed2.blocks.get(BASE_KEY4);
+      if (!base) return null;
+      const sides = MARGIN_SIDES.map((p2) => base.decls.get(p2));
+      if (sides.some((d3) => d3 === void 0)) return null;
+      const [mt, mr, mb, ml] = sides;
+      if (mt.important || mr.important || mb.important || ml.important) return null;
+      const value = collapseMarginValue(
+        String(mt.value),
+        String(mr.value),
+        String(mb.value),
+        String(ml.value)
+      );
+      const marginDecl = {
+        property: "margin",
+        value,
+        important: false,
+        relativeToParent: mt.relativeToParent || mr.relativeToParent || mb.relativeToParent || ml.relativeToParent,
+        inherited: false
+        // margin is not an inherited property
+      };
+      return withFoldedMargin(computed2, marginDecl);
+    }
+  },
+  test: {
+    cases: [
+      {
+        // The four equal margin longhands collapse to a `margin` shorthand at the IR level, and the
+        // minimizing reverse-emit picks the single shortest utility (`m-2`) reproducing it, replacing
+        // the four `m{t,r,b,l}-2` tokens. `bg-red-200` is preserved.
+        before: '<div className="mt-2 mr-2 mb-2 ml-2 bg-red-200">box</div>',
+        after: '<div className="bg-red-200 m-2">box</div>'
+      }
+    ],
+    // Only two margin sides set → the four-longhand `margin` collapse does not apply.
+    noMatch: ['<div className="mt-2 mb-2 bg-red-200">box</div>']
+  }
+});
+
+// ../patterns/src/library/compress/overflow-shorthand.pattern.ts
+init_cjs_shims();
+var OVERFLOW_X = "overflow-x";
+var OVERFLOW_Y = "overflow-y";
+var OVERFLOW = "overflow";
+var BASE_KEY5 = conditionKey(BASE_CONDITION);
+function withOverflowShorthand(sm, overflowDecl) {
+  const blocks = /* @__PURE__ */ new Map();
+  for (const [key, block] of sm.blocks) {
+    if (key !== BASE_KEY5) {
+      blocks.set(key, block);
+      continue;
+    }
+    const decls = /* @__PURE__ */ new Map();
+    for (const [prop, decl] of block.decls) {
+      if (prop === OVERFLOW_X || prop === OVERFLOW_Y) continue;
+      decls.set(prop, decl);
+    }
+    decls.set(overflowDecl.property, overflowDecl);
+    blocks.set(key, { condition: block.condition, decls });
+  }
+  return { blocks };
+}
+var overflowShorthand = definePattern({
+  name: "overflow-shorthand",
+  category: "compress/overflow-shorthand",
+  safety: 1,
+  doc: {
+    title: "Collapse equal overflow axes into the `overflow` shorthand",
+    summary: "An element whose computed overflow-x and overflow-y are equal has the two axis longhands collapsed into a single `overflow` shorthand (Tailwind overflow-x-* overflow-y-* \u2192 overflow-*).",
+    before: '<div style="overflow-x:auto;overflow-y:auto"/>',
+    after: '<div style="overflow:auto"/>',
+    safetyRationale: "A single-keyword `overflow` is value-identical to equal overflow-x+overflow-y \u2014 a class-only change. It is safe even on an element with a ref, event handler, dynamic child, or dangerouslySetInnerHTML \u2014 a className rewrite touches none of them; only a dynamic/opaque class list or a combinator-subject class is excluded, so no behaviour or project selector is disturbed."
+  },
+  rewrite: {
+    rewriteClasses(computed2) {
+      const base = computed2.blocks.get(BASE_KEY5);
+      if (!base) return null;
+      const overflowX = base.decls.get(OVERFLOW_X);
+      const overflowY = base.decls.get(OVERFLOW_Y);
+      if (!overflowX || !overflowY) return null;
+      if (overflowX.important !== overflowY.important) return null;
+      if (overflowX.value !== overflowY.value) return null;
+      const overflowDecl = {
+        property: OVERFLOW,
+        value: overflowX.value,
+        important: overflowX.important,
+        relativeToParent: overflowX.relativeToParent || overflowY.relativeToParent,
+        inherited: false
+        // overflow is not an inherited property
+      };
+      return withOverflowShorthand(computed2, overflowDecl);
+    }
+  },
+  test: {
+    cases: [
+      {
+        // Equal overflow axes collapse to an `overflow` decl at the IR level; the minimizing
+        // reverse-emit picks the single utility covering both (`overflow-auto`), replacing the
+        // `overflow-x-auto`+`overflow-y-auto` pair. `bg-red-200` is preserved.
+        before: '<div className="overflow-x-auto overflow-y-auto bg-red-200">box</div>',
+        after: '<div className="bg-red-200 overflow-auto">box</div>'
+      }
+    ],
+    // Mismatched axes (overflow-x != overflow-y) have no single-keyword equivalent → not collapsed.
+    noMatch: ['<div className="overflow-x-auto overflow-y-hidden bg-red-200">box</div>']
+  }
+});
+
+// ../patterns/src/library/compress/overscroll-behavior-shorthand.pattern.ts
+init_cjs_shims();
+var OVERSCROLL_X = "overscroll-behavior-x";
+var OVERSCROLL_Y = "overscroll-behavior-y";
+var OVERSCROLL = "overscroll-behavior";
+var BASE_KEY6 = conditionKey(BASE_CONDITION);
+var NON_COLLAPSIBLE_VALUES2 = /* @__PURE__ */ new Set([
+  "initial",
+  "inherit",
+  "unset",
+  "revert",
+  "revert-layer"
+]);
+function withOverscrollShorthand(sm, shorthand) {
+  const blocks = /* @__PURE__ */ new Map();
+  for (const [key, block] of sm.blocks) {
+    if (key !== BASE_KEY6) {
+      blocks.set(key, block);
+      continue;
+    }
+    const decls = /* @__PURE__ */ new Map();
+    for (const [prop, decl] of block.decls) {
+      if (prop === OVERSCROLL_X || prop === OVERSCROLL_Y) continue;
+      decls.set(prop, decl);
+    }
+    decls.set(shorthand.property, shorthand);
+    blocks.set(key, { condition: block.condition, decls });
+  }
+  return { blocks };
+}
+var overscrollBehaviorShorthand = definePattern({
+  name: "overscroll-behavior-shorthand",
+  category: "compress/overscroll-behavior-shorthand",
+  safety: 1,
+  doc: {
+    title: "Collapse equal overscroll-behavior axes into overscroll-behavior",
+    summary: "An element whose computed overscroll-behavior-x and overscroll-behavior-y are equal has the two axis longhands collapsed into a single `overscroll-behavior` shorthand (Tailwind overscroll-x-* overscroll-y-* \u2192 overscroll-*).",
+    before: '<div style="overscroll-behavior-x:contain;overscroll-behavior-y:contain"/>',
+    after: '<div class="overscroll-contain"/>',
+    safetyRationale: "`overscroll-behavior` is value-identical to an equal x+y axis pair \u2014 a class-only change. It is safe even on an element with a ref, event handler, dynamic child, or dangerouslySetInnerHTML \u2014 a className rewrite touches none of them; only a dynamic/opaque class list or a combinator-subject class is excluded, so no behaviour or project selector is disturbed."
+  },
+  rewrite: {
+    rewriteClasses(computed2) {
+      const base = computed2.blocks.get(BASE_KEY6);
+      if (!base) return null;
+      const x2 = base.decls.get(OVERSCROLL_X);
+      const y3 = base.decls.get(OVERSCROLL_Y);
+      if (!x2 || !y3) return null;
+      if (x2.important !== y3.important) return null;
+      const value = String(x2.value);
+      if (NON_COLLAPSIBLE_VALUES2.has(value)) return null;
+      if (value !== String(y3.value)) return null;
+      const shorthand = {
+        property: OVERSCROLL,
+        value: x2.value,
+        important: x2.important,
+        relativeToParent: x2.relativeToParent || y3.relativeToParent,
+        inherited: false
+        // overscroll-behavior is not an inherited property
+      };
+      return withOverscrollShorthand(computed2, shorthand);
+    }
+  },
+  test: {
+    cases: [
+      {
+        // Equal x/y axes collapse to an `overscroll-behavior` decl at the IR level; the minimizing
+        // reverse-emit picks the single utility covering both (`overscroll-contain`), replacing the
+        // `overscroll-x-contain`+`overscroll-y-contain` pair. `bg-red-200` is preserved.
+        before: '<div className="overscroll-x-contain overscroll-y-contain bg-red-200">box</div>',
+        after: '<div className="bg-red-200 overscroll-contain">box</div>'
+      }
+    ],
+    // Axes differ (x != y) → no equal-axis collapse.
+    noMatch: ['<div className="overscroll-x-contain overscroll-y-auto bg-red-200">box</div>']
+  }
+});
+
+// ../patterns/src/library/compress/padding-shorthand.pattern.ts
+init_cjs_shims();
+var PADDING_SIDES = [
+  "padding-top",
+  "padding-right",
+  "padding-bottom",
+  "padding-left"
+];
+var PADDING_SIDE_SET = new Set(PADDING_SIDES);
+var BASE_KEY7 = conditionKey(BASE_CONDITION);
+function analyzePadding(sm) {
+  const block = sm.blocks.get(BASE_KEY7);
+  if (!block) return null;
+  const sides = [];
+  for (const side of PADDING_SIDES) {
+    const decl = block.decls.get(side);
+    if (!decl) return null;
+    sides.push(decl);
+  }
+  const [top, right, bottom, left] = sides;
+  if (!(top.important === right.important && right.important === bottom.important && bottom.important === left.important)) {
+    return null;
+  }
+  const tv = String(top.value);
+  const rv = String(right.value);
+  const bv = String(bottom.value);
+  const lv = String(left.value);
+  if (tv !== bv || lv !== rv) return null;
+  const value = tv === lv ? tv : `${tv} ${lv}`;
+  const relative4 = sides.some((d3) => d3.relativeToParent);
+  return { value, important: top.important, relative: relative4 };
+}
+function withFoldedPadding(sm, fold) {
+  const blocks = /* @__PURE__ */ new Map();
+  for (const [key, block] of sm.blocks) {
+    if (key !== BASE_KEY7) {
+      blocks.set(key, block);
+      continue;
+    }
+    const decls = /* @__PURE__ */ new Map();
+    for (const [prop, decl] of block.decls) {
+      if (PADDING_SIDE_SET.has(String(prop))) continue;
+      decls.set(prop, decl);
+    }
+    const shorthand = {
+      property: "padding",
+      value: fold.value,
+      important: fold.important,
+      relativeToParent: fold.relative,
+      inherited: false
+      // padding is never inherited
+    };
+    decls.set(shorthand.property, shorthand);
+    blocks.set(key, { condition: block.condition, decls });
+  }
+  return { blocks };
+}
+var paddingShorthand = definePattern({
+  name: "padding-shorthand",
+  category: "compress/padding-shorthand",
+  safety: 1,
+  doc: {
+    title: "Collapse padding longhands to shorthand",
+    summary: "Equal padding on all four sides (or matching x/y pairs) expressed as separate longhand declarations is collapsed to the shortest equivalent padding shorthand (p-* / px-* py-*).",
+    before: '<div class="pt-4 pr-4 pb-4 pl-4"/>',
+    after: '<div class="p-4"/>',
+    safetyRationale: "A value-preserving re-serialization of the same computed padding on the same node \u2014 a class-only change. It is safe even on an element with a ref, event handler, dynamic child, or dangerouslySetInnerHTML \u2014 a className rewrite touches none of them; only a dynamic/opaque class list or a combinator-subject class is excluded, so no behaviour or project selector is disturbed."
+  },
+  rewrite: {
+    rewriteClasses(computed2) {
+      const fold = analyzePadding(computed2);
+      return fold ? withFoldedPadding(computed2, fold) : null;
+    }
+  },
+  test: {
+    cases: [
+      {
+        // The four equal padding longhands collapse to a `padding` shorthand at the IR level, and the
+        // minimizing reverse-emit picks the single shortest utility (`p-4`) that reproduces it,
+        // replacing the four `p{t,r,b,l}-4` tokens. `bg-red-200` is preserved (its order is stable).
+        before: '<div className="pt-4 pr-4 pb-4 pl-4 bg-red-200">box</div>',
+        after: '<div className="bg-red-200 p-4">box</div>'
+      },
+      {
+        // A dynamic `{x}` child no longer blocks compress: only the element's OWN class tokens are
+        // rewritten (px-4 py-4 → p-4); the dynamic child is untouched by a class-only change. This is
+        // the real-app common case (most elements have dynamic content).
+        before: '<div className="px-4 py-4">{x}</div>',
+        after: '<div className="p-4">{x}</div>'
+      }
+    ],
+    // Asymmetric padding (top != bottom) cannot fold into a shorthand → left unchanged.
+    noMatch: ['<div className="pt-2 pr-4 pb-8 pl-4 bg-red-200">box</div>']
+  }
+});
+
+// ../patterns/src/library/compress/place-shorthand.pattern.ts
+init_cjs_shims();
+var ALIGN_ITEMS = "align-items";
+var JUSTIFY_ITEMS = "justify-items";
+var PLACE_ITEMS = "place-items";
+var ALIGN_CONTENT = "align-content";
+var JUSTIFY_CONTENT = "justify-content";
+var PLACE_CONTENT = "place-content";
+var BASE_KEY8 = conditionKey(BASE_CONDITION);
+function samePair(a, b3) {
+  return a !== void 0 && b3 !== void 0 && a.value === b3.value && a.important === b3.important;
+}
+function placeDecl(property, align) {
+  return {
+    property,
+    value: align.value,
+    important: align.important,
+    relativeToParent: false,
+    // alignment keywords (center/start/stretch/…) are not length-relative
+    inherited: false
+    // none of the place-* alignment properties are inherited
+  };
+}
+function withBaseDecls2(sm, baseDecls) {
+  const blocks = /* @__PURE__ */ new Map();
+  for (const [key, block] of sm.blocks) {
+    const decls = key === BASE_KEY8 ? new Map(baseDecls) : block.decls;
+    blocks.set(key, { condition: block.condition, decls });
+  }
+  return { blocks };
+}
+var placeShorthand = definePattern({
+  name: "place-shorthand",
+  category: "compress/place-shorthand",
+  safety: 1,
+  doc: {
+    title: "Collapse matching alignment pairs into `place-*` shorthands",
+    summary: "When align-items equals justify-items they collapse to `place-items`; when align-content equals justify-content they collapse to `place-content`. The two collapses are independent.",
+    before: '<div style="align-items:center;justify-items:center"/>',
+    after: '<div style="place-items:center"/>',
+    safetyRationale: "A `place-*` shorthand is value-identical to its equal align/justify pair \u2014 a class-only change. It is safe even on an element with a ref, event handler, dynamic child, or dangerouslySetInnerHTML \u2014 a className rewrite touches none of them; only a dynamic/opaque class list or a combinator-subject class is excluded, so no behaviour or project selector is disturbed."
+  },
+  rewrite: {
+    rewriteClasses(computed2) {
+      const base = computed2.blocks.get(BASE_KEY8);
+      if (!base) return null;
+      const alignItems = base.decls.get(ALIGN_ITEMS);
+      const justifyItems = base.decls.get(JUSTIFY_ITEMS);
+      const alignContent = base.decls.get(ALIGN_CONTENT);
+      const justifyContent = base.decls.get(JUSTIFY_CONTENT);
+      const next = new Map(base.decls);
+      let collapsed = false;
+      if (samePair(alignItems, justifyItems)) {
+        next.delete(ALIGN_ITEMS);
+        next.delete(JUSTIFY_ITEMS);
+        next.set(PLACE_ITEMS, placeDecl(PLACE_ITEMS, alignItems));
+        collapsed = true;
+      }
+      if (samePair(alignContent, justifyContent)) {
+        next.delete(ALIGN_CONTENT);
+        next.delete(JUSTIFY_CONTENT);
+        next.set(PLACE_CONTENT, placeDecl(PLACE_CONTENT, alignContent));
+        collapsed = true;
+      }
+      if (!collapsed) return null;
+      return withBaseDecls2(computed2, next);
+    }
+  },
+  test: {
+    cases: [
+      {
+        // The matching items pair collapses to a `place-items` decl at the IR level; the minimizing
+        // reverse-emit picks the single utility covering both (`place-items-center`), replacing the
+        // `items-center`+`justify-items-center` pair. `bg-red-200` is preserved.
+        before: '<div className="items-center justify-items-center bg-red-200">box</div>',
+        after: '<div className="bg-red-200 place-items-center">box</div>'
+      }
+    ],
+    // Mismatched alignment (align-items != justify-items, no content pair) → nothing collapses.
+    noMatch: ['<div className="items-center justify-items-start bg-red-200">box</div>']
+  }
+});
+
+// ../patterns/src/library/compress/scroll-margin-shorthand.pattern.ts
+init_cjs_shims();
+var SCROLL_MARGIN_SIDES = [
+  "scroll-margin-top",
+  "scroll-margin-right",
+  "scroll-margin-bottom",
+  "scroll-margin-left"
+];
+var SIDE_SET = new Set(SCROLL_MARGIN_SIDES);
+var BASE_KEY9 = conditionKey(BASE_CONDITION);
+var SCROLL_MARGIN = "scroll-margin";
+var NON_COLLAPSIBLE_VALUES3 = /* @__PURE__ */ new Set([
+  "initial",
+  "inherit",
+  "unset",
+  "revert",
+  "revert-layer"
+]);
+function analyzeScrollMargin(sm) {
+  const block = sm.blocks.get(BASE_KEY9);
+  if (!block) return null;
+  const sides = [];
+  for (const side of SCROLL_MARGIN_SIDES) {
+    const decl = block.decls.get(side);
+    if (!decl) return null;
+    sides.push(decl);
+  }
+  const important = sides[0].important;
+  if (!sides.every((d3) => d3.important === important)) return null;
+  const value = String(sides[0].value);
+  if (NON_COLLAPSIBLE_VALUES3.has(value)) return null;
+  if (!sides.every((d3) => String(d3.value) === value)) return null;
+  const relative4 = sides.some((d3) => d3.relativeToParent);
+  return { value, important, relative: relative4 };
+}
+function withFoldedScrollMargin(sm, fold) {
+  const blocks = /* @__PURE__ */ new Map();
+  for (const [key, block] of sm.blocks) {
+    if (key !== BASE_KEY9) {
+      blocks.set(key, block);
+      continue;
+    }
+    const decls = /* @__PURE__ */ new Map();
+    for (const [prop, decl] of block.decls) {
+      if (SIDE_SET.has(String(prop))) continue;
+      decls.set(prop, decl);
+    }
+    const shorthand = {
+      property: SCROLL_MARGIN,
+      value: fold.value,
+      important: fold.important,
+      relativeToParent: fold.relative,
+      inherited: false
+      // scroll-margin is never inherited
+    };
+    decls.set(shorthand.property, shorthand);
+    blocks.set(key, { condition: block.condition, decls });
+  }
+  return { blocks };
+}
+var scrollMarginShorthand = definePattern({
+  name: "scroll-margin-shorthand",
+  category: "compress/scroll-margin-shorthand",
+  safety: 1,
+  doc: {
+    title: "Collapse equal scroll-margin sides into scroll-margin",
+    summary: "An element whose four scroll-margin sides are all equal is rewritten to the single Tailwind scroll-m-* utility (scroll-margin === the four equal sides).",
+    before: '<div class="scroll-mt-4 scroll-mr-4 scroll-mb-4 scroll-ml-4"/>',
+    after: '<div class="scroll-m-4"/>',
+    safetyRationale: "`scroll-margin` is value-identical to four equal scroll-margin sides \u2014 a class-only change. It is safe even on an element with a ref, event handler, dynamic child, or dangerouslySetInnerHTML \u2014 a className rewrite touches none of them; only a dynamic/opaque class list or a combinator-subject class is excluded, so no behaviour or project selector is disturbed."
   },
   rewrite: {
     rewriteClasses(computed2) {
-      const base = computed2.blocks.get(BASE_KEY);
-      if (!base) return null;
-      const sides = MARGIN_SIDES.map((p2) => base.decls.get(p2));
-      if (sides.some((d3) => d3 === void 0)) return null;
-      const [mt, mr, mb, ml] = sides;
-      if (mt.important || mr.important || mb.important || ml.important) return null;
-      const value = collapseMarginValue(
-        String(mt.value),
-        String(mr.value),
-        String(mb.value),
-        String(ml.value)
-      );
-      const marginDecl = {
-        property: "margin",
-        value,
-        important: false,
-        relativeToParent: mt.relativeToParent || mr.relativeToParent || mb.relativeToParent || ml.relativeToParent,
-        inherited: false
-        // margin is not an inherited property
-      };
-      return withFoldedMargin(computed2, marginDecl);
+      const fold = analyzeScrollMargin(computed2);
+      return fold ? withFoldedScrollMargin(computed2, fold) : null;
     }
   },
-  examples: [
-    {
-      // The four equal margin longhands collapse to a `margin` shorthand at the IR level, and the
-      // minimizing reverse-emit picks the single shortest utility (`m-2`) reproducing it, replacing
-      // the four `m{t,r,b,l}-2` tokens. `bg-red-200` is preserved.
-      before: '<div className="mt-2 mr-2 mb-2 ml-2 bg-red-200">box</div>',
-      after: '<div className="bg-red-200 m-2">box</div>'
-    },
-    {
-      // Only two margin sides set → the four-longhand `margin` collapse does not apply.
-      noMatch: '<div className="mt-2 mb-2 bg-red-200">box</div>'
-    }
-  ]
+  test: {
+    cases: [
+      {
+        // The four equal scroll-margin longhands collapse to a `scroll-margin` decl at the IR level; the
+        // minimizing reverse-emit then picks the single shortest utility (`scroll-m-4`) that reproduces
+        // it, replacing the four `scroll-m{t,r,b,l}-4` tokens. `bg-red-200` is preserved.
+        before: '<div className="scroll-mt-4 scroll-mr-4 scroll-mb-4 scroll-ml-4 bg-red-200">box</div>',
+        after: '<div className="bg-red-200 scroll-m-4">box</div>'
+      }
+    ],
+    // Sides differ (top != bottom) → no all-equal collapse.
+    noMatch: ['<div className="scroll-mt-2 scroll-mr-4 scroll-mb-8 scroll-ml-4 bg-red-200">box</div>']
+  }
 });
 
-// ../patterns/src/compress/padding-shorthand.pattern.ts
+// ../patterns/src/library/compress/scroll-padding-shorthand.pattern.ts
 init_cjs_shims();
-var PADDING_SIDES = [
-  "padding-top",
-  "padding-right",
-  "padding-bottom",
-  "padding-left"
+var SCROLL_PADDING_SIDES = [
+  "scroll-padding-top",
+  "scroll-padding-right",
+  "scroll-padding-bottom",
+  "scroll-padding-left"
 ];
-var PADDING_SIDE_SET = new Set(PADDING_SIDES);
-var BASE_KEY2 = conditionKey(BASE_CONDITION);
-function analyzePadding(sm) {
-  const block = sm.blocks.get(BASE_KEY2);
+var SIDE_SET2 = new Set(SCROLL_PADDING_SIDES);
+var BASE_KEY10 = conditionKey(BASE_CONDITION);
+var SCROLL_PADDING = "scroll-padding";
+var NON_COLLAPSIBLE_VALUES4 = /* @__PURE__ */ new Set([
+  "initial",
+  "inherit",
+  "unset",
+  "revert",
+  "revert-layer"
+]);
+function analyzeScrollPadding(sm) {
+  const block = sm.blocks.get(BASE_KEY10);
   if (!block) return null;
   const sides = [];
-  for (const side of PADDING_SIDES) {
+  for (const side of SCROLL_PADDING_SIDES) {
     const decl = block.decls.get(side);
     if (!decl) return null;
     sides.push(decl);
   }
-  const [top, right, bottom, left] = sides;
-  if (!(top.important === right.important && right.important === bottom.important && bottom.important === left.important)) {
-    return null;
-  }
-  const tv = String(top.value);
-  const rv = String(right.value);
-  const bv = String(bottom.value);
-  const lv = String(left.value);
-  if (tv !== bv || lv !== rv) return null;
-  const value = tv === lv ? tv : `${tv} ${lv}`;
-  const relative3 = sides.some((d3) => d3.relativeToParent);
-  return { value, important: top.important, relative: relative3 };
+  const important = sides[0].important;
+  if (!sides.every((d3) => d3.important === important)) return null;
+  const value = String(sides[0].value);
+  if (NON_COLLAPSIBLE_VALUES4.has(value)) return null;
+  if (!sides.every((d3) => String(d3.value) === value)) return null;
+  const relative4 = sides.some((d3) => d3.relativeToParent);
+  return { value, important, relative: relative4 };
 }
-var isInert = (node) => {
-  const n = node;
-  if (n.kind !== "element") return false;
-  const el = n;
-  return !el.meta.hasDangerousHtml && !el.meta.hasSpreadAttrs && !el.isComponent;
-};
-function withFoldedPadding(sm, fold) {
+function withFoldedScrollPadding(sm, fold) {
   const blocks = /* @__PURE__ */ new Map();
   for (const [key, block] of sm.blocks) {
-    if (key !== BASE_KEY2) {
+    if (key !== BASE_KEY10) {
       blocks.set(key, block);
       continue;
     }
     const decls = /* @__PURE__ */ new Map();
     for (const [prop, decl] of block.decls) {
-      if (PADDING_SIDE_SET.has(String(prop))) continue;
+      if (SIDE_SET2.has(String(prop))) continue;
       decls.set(prop, decl);
     }
     const shorthand = {
-      property: "padding",
+      property: SCROLL_PADDING,
       value: fold.value,
       important: fold.important,
       relativeToParent: fold.relative,
       inherited: false
-      // padding is never inherited
+      // scroll-padding is never inherited
     };
     decls.set(shorthand.property, shorthand);
     blocks.set(key, { condition: block.condition, decls });
   }
   return { blocks };
 }
-var paddingShorthand = pattern({
-  name: "padding-shorthand",
-  category: "compress/padding-shorthand",
+var scrollPaddingShorthand = definePattern({
+  name: "scroll-padding-shorthand",
+  category: "compress/scroll-padding-shorthand",
   safety: 1,
   doc: {
-    title: "Collapse padding longhands to shorthand",
-    summary: "Equal padding on all four sides (or matching x/y pairs) expressed as separate longhand declarations is collapsed to the shortest equivalent padding shorthand (p-* / px-* py-*).",
-    before: '<div class="pt-4 pr-4 pb-4 pl-4"/>',
-    after: '<div class="p-4"/>',
-    safetyRationale: "A value-preserving re-serialization of the same computed styles on the same node; it skips nodes with ref/handlers/dynamic children/dynamic classes/dangerous html and combinator subjects, so no JS identity, behaviour, or project selector is disturbed."
-  },
-  match: {
-    where: [
-      not(hasRef),
-      not(hasEventHandlers),
-      not(hasDynamicChildren),
-      not(hasDynamicClasses),
-      not(targetedByCombinator),
-      isInert
-    ]
+    title: "Collapse equal scroll-padding sides into scroll-padding",
+    summary: "An element whose four scroll-padding sides are all equal is rewritten to the single Tailwind scroll-p-* utility (scroll-padding === the four equal sides).",
+    before: '<div class="scroll-pt-4 scroll-pr-4 scroll-pb-4 scroll-pl-4"/>',
+    after: '<div class="scroll-p-4"/>',
+    safetyRationale: "`scroll-padding` is value-identical to four equal scroll-padding sides \u2014 a class-only change. It is safe even on an element with a ref, event handler, dynamic child, or dangerouslySetInnerHTML \u2014 a className rewrite touches none of them; only a dynamic/opaque class list or a combinator-subject class is excluded, so no behaviour or project selector is disturbed."
   },
   rewrite: {
     rewriteClasses(computed2) {
-      const fold = analyzePadding(computed2);
-      return fold ? withFoldedPadding(computed2, fold) : null;
+      const fold = analyzeScrollPadding(computed2);
+      return fold ? withFoldedScrollPadding(computed2, fold) : null;
     }
   },
-  examples: [
-    {
-      // The four equal padding longhands collapse to a `padding` shorthand at the IR level, and the
-      // minimizing reverse-emit picks the single shortest utility (`p-4`) that reproduces it,
-      // replacing the four `p{t,r,b,l}-4` tokens. `bg-red-200` is preserved (its order is stable).
-      before: '<div className="pt-4 pr-4 pb-4 pl-4 bg-red-200">box</div>',
-      after: '<div className="bg-red-200 p-4">box</div>'
-    },
-    {
-      // Asymmetric padding (top != bottom) cannot fold into a shorthand.
-      noMatch: '<div className="pt-2 pr-4 pb-8 pl-4 bg-red-200">box</div>'
-    }
-  ]
+  test: {
+    cases: [
+      {
+        // The four equal scroll-padding longhands collapse to a `scroll-padding` decl at the IR level;
+        // the minimizing reverse-emit then picks the single shortest utility (`scroll-p-4`) that
+        // reproduces it, replacing the four `scroll-p{t,r,b,l}-4` tokens. `bg-red-200` is preserved.
+        before: '<div className="scroll-pt-4 scroll-pr-4 scroll-pb-4 scroll-pl-4 bg-red-200">box</div>',
+        after: '<div className="bg-red-200 scroll-p-4">box</div>'
+      }
+    ],
+    // Sides differ (top != bottom) → no all-equal collapse.
+    noMatch: ['<div className="scroll-pt-2 scroll-pr-4 scroll-pb-8 scroll-pl-4 bg-red-200">box</div>']
+  }
 });
 
-// ../patterns/src/compress/size-shorthand.pattern.ts
+// ../patterns/src/library/compress/size-shorthand.pattern.ts
 init_cjs_shims();
 var WIDTH = "width";
 var HEIGHT = "height";
 var SIZE = "size";
-var NON_COLLAPSIBLE_VALUES = /* @__PURE__ */ new Set(["auto", "initial", "unset"]);
-function asElement4(node) {
-  const n = node;
-  return n.kind === "element" ? n : null;
-}
+var NON_COLLAPSIBLE_VALUES5 = /* @__PURE__ */ new Set(["auto", "initial", "unset"]);
 function baseBlock(sm) {
   return sm.blocks.get(conditionKey(BASE_CONDITION));
 }
-var hasDangerousHtml3 = (node) => asElement4(node)?.meta.hasDangerousHtml ?? false;
 function withSizeShorthand(sm, value, important) {
   const baseKey = conditionKey(BASE_CONDITION);
   const blocks = /* @__PURE__ */ new Map();
@@ -3299,7 +4518,7 @@ function withSizeShorthand(sm, value, important) {
   }
   return { blocks };
 }
-var sizeShorthand = pattern({
+var sizeShorthand = definePattern({
   name: "size-shorthand",
   category: "compress/size-shorthand",
   safety: 2,
@@ -3308,17 +4527,7 @@ var sizeShorthand = pattern({
     summary: "An element whose computed width and height are equal is rewritten to the single Tailwind size-* utility (size-* === width + height at the same value).",
     before: '<div style="width:1rem;height:1rem"/>',
     after: '<div class="size-4"/>',
-    safetyRationale: "size-* is value-identical to equal width+height; the element carries no ref/handlers/dynamic children/dangerous HTML, no dynamic class segment, and is not a combinator subject."
-  },
-  match: {
-    where: [
-      not(hasRef),
-      not(hasEventHandlers),
-      not(hasDynamicChildren),
-      not(hasDangerousHtml3),
-      not(hasDynamicClasses),
-      not(targetedByCombinator)
-    ]
+    safetyRationale: "`size-*` is value-identical to equal width+height \u2014 a class-only change. It is safe even on an element with a ref, event handler, dynamic child, or dangerouslySetInnerHTML \u2014 a className rewrite touches none of them; only a dynamic/opaque class list or a combinator-subject class is excluded, so no behaviour or project selector is disturbed."
   },
   rewrite: {
     rewriteClasses(computed2) {
@@ -3327,43 +4536,91 @@ var sizeShorthand = pattern({
       const h2 = base?.decls.get(HEIGHT);
       if (!w2 || !h2) return null;
       if (w2.important !== h2.important) return null;
-      if (NON_COLLAPSIBLE_VALUES.has(String(w2.value))) return null;
+      if (NON_COLLAPSIBLE_VALUES5.has(String(w2.value))) return null;
       if (w2.value !== h2.value) return null;
       return withSizeShorthand(computed2, String(w2.value), w2.important);
     }
   },
-  examples: [
-    {
-      // Equal width/height collapse to a `size` decl at the IR level; the minimizing reverse-emit
-      // expands `size` back to width+height, finds the single utility covering both (`size-10`), and
-      // replaces the `h-10`+`w-10` pair with it. `bg-red-200` is preserved.
-      before: '<div className="h-10 w-10 bg-red-200">box</div>',
-      after: '<div className="bg-red-200 size-10">box</div>'
-    },
-    {
-      // Width and height differ → no equal-axis collapse.
-      noMatch: '<div className="h-10 w-20 bg-red-200">box</div>'
-    }
-  ]
+  test: {
+    cases: [
+      {
+        // Equal width/height collapse to a `size` decl at the IR level; the minimizing reverse-emit
+        // expands `size` back to width+height, finds the single utility covering both (`size-10`), and
+        // replaces the `h-10`+`w-10` pair with it. `bg-red-200` is preserved.
+        before: '<div className="h-10 w-10 bg-red-200">box</div>',
+        after: '<div className="bg-red-200 size-10">box</div>'
+      }
+    ],
+    // Width and height differ → no equal-axis collapse.
+    noMatch: ['<div className="h-10 w-20 bg-red-200">box</div>']
+  }
 });
 
 // ../patterns/src/_registry.generated.ts
 var builtinPatterns = [
+  displayContentsWrapper,
   emptyStyleDiv,
   flexCenterWrapper,
+  inlineFlexCenterWrapper,
   nestedFlexMerge,
+  nestedGridMerge,
   passthroughWrapper,
   redundantFragment,
+  redundantInlineWrapper,
+  borderRadiusShorthand,
+  borderShorthand,
   dedupeClasses,
+  gapShorthand,
   insetShorthand,
   marginShorthand,
+  overflowShorthand,
+  overscrollBehaviorShorthand,
   paddingShorthand,
+  placeShorthand,
+  scrollMarginShorthand,
+  scrollPaddingShorthand,
   sizeShorthand
 ];
 
 // ../resolver-css/src/index.ts
 init_cjs_shims();
-var import_node_fs = require("fs");
+
+// ../resolver-css/src/constants.ts
+init_cjs_shims();
+var CSS_RESOLVER_ID = "css";
+var CSS_RESOLVER_PROVIDER = "custom-css";
+var ENGINE_VERSION = "css-index@1";
+var STRUCTURAL_PSEUDOS = /* @__PURE__ */ new Set([
+  ":nth-child",
+  ":nth-last-child",
+  ":first-child",
+  ":last-child",
+  ":only-child",
+  ":nth-of-type",
+  ":nth-last-of-type",
+  ":first-of-type",
+  ":last-of-type",
+  ":only-of-type"
+]);
+var FUNCTIONAL_PSEUDOS = /* @__PURE__ */ new Set([
+  ":not",
+  ":is",
+  ":where",
+  ":has",
+  ":matches"
+]);
+var LEGACY_PSEUDO_ELEMENTS = /* @__PURE__ */ new Set([
+  ":before",
+  ":after",
+  ":first-line",
+  ":first-letter"
+]);
+
+// ../resolver-css/src/resolver.ts
+init_cjs_shims();
+
+// ../resolver-css/src/engine.ts
+init_cjs_shims();
 var import_node_module = require("module");
 var path2 = __toESM(require("path"), 1);
 function moduleBase() {
@@ -3401,34 +4658,82 @@ function ensurePostcss(projectRoot) {
   pc = engine.parse;
   sp = engine.selectorParser;
 }
-var CSS_RESOLVER_ID = "css";
-var CSS_RESOLVER_PROVIDER = "custom-css";
-var ENGINE_VERSION = "css-index@1";
-var STRUCTURAL_PSEUDOS = /* @__PURE__ */ new Set([
-  ":nth-child",
-  ":nth-last-child",
-  ":first-child",
-  ":last-child",
-  ":only-child",
-  ":nth-of-type",
-  ":nth-last-of-type",
-  ":first-of-type",
-  ":last-of-type",
-  ":only-of-type"
-]);
-var FUNCTIONAL_PSEUDOS = /* @__PURE__ */ new Set([
-  ":not",
-  ":is",
-  ":where",
-  ":has",
-  ":matches"
-]);
-var LEGACY_PSEUDO_ELEMENTS = /* @__PURE__ */ new Set([
-  ":before",
-  ":after",
-  ":first-line",
-  ":first-letter"
-]);
+
+// ../resolver-css/src/postcss-helpers.ts
+init_cjs_shims();
+function mediaContext(rule) {
+  const parts = [];
+  let skip = false;
+  let parent = rule.parent;
+  while (parent && parent.type === "atrule") {
+    const at = parent;
+    const name = at.name.toLowerCase();
+    if (name === "media") parts.unshift(at.params.trim().replace(/\s+/g, " "));
+    else if (name === "keyframes" || name.endsWith("keyframes") || name === "font-face") skip = true;
+    parent = parent.parent;
+  }
+  return { media: parts.join(" and "), skip };
+}
+function collectDecls(rule) {
+  const out = [];
+  for (const node of rule.nodes) {
+    if (node.type === "decl") out.push([node.prop, node.value, node.important === true]);
+  }
+  return out;
+}
+
+// ../resolver-css/src/misc-helpers.ts
+init_cjs_shims();
+var import_node_fs = require("fs");
+function isPlainClassToken(token) {
+  return token.length > 0 && !/[\s.#>+~:[\]()]/.test(token);
+}
+function readCssPath(path7) {
+  try {
+    return { id: path7, css: (0, import_node_fs.readFileSync)(path7, "utf8") };
+  } catch (cause) {
+    throw new Error(`resolver-css: cannot read CSS file "${path7}"`, { cause });
+  }
+}
+function deriveFingerprint(provider, files) {
+  const parts = files.map((f) => `${f.id}:${f.css.length}`).sort();
+  return `${provider}/${ENGINE_VERSION}::${parts.join("|")}`;
+}
+
+// ../resolver-css/src/selector-helpers.ts
+init_cjs_shims();
+function splitCompounds(selector) {
+  const compounds = [];
+  let current = [];
+  let leftCombinator = null;
+  for (const node of selector.nodes) {
+    if (sp.isCombinator(node)) {
+      compounds.push({ leftCombinator, nodes: current });
+      current = [];
+      leftCombinator = combinatorValue(node);
+    } else {
+      current.push(node);
+    }
+  }
+  compounds.push({ leftCombinator, nodes: current });
+  return compounds;
+}
+function combinatorValue(node) {
+  const v2 = node.value;
+  return v2.trim() === "" ? " " : v2.trim();
+}
+function pseudoName(node) {
+  return node.value.toLowerCase();
+}
+function isPseudoElement(node) {
+  return sp.isPseudoElement(node) || LEGACY_PSEUDO_ELEMENTS.has(pseudoName(node));
+}
+function normalizePseudoElement(node) {
+  const name = pseudoName(node);
+  return name.startsWith("::") ? name : `::${name.replace(/^:/, "")}`;
+}
+
+// ../resolver-css/src/resolver.ts
 var CustomCSSResolver = class {
   id = CSS_RESOLVER_ID;
   provider = CSS_RESOLVER_PROVIDER;
@@ -3478,7 +4783,7 @@ var CustomCSSResolver = class {
     const remaining = /* @__PURE__ */ new Map();
     for (const [ck, block] of norm.normalizeStyleMap(styles).blocks) {
       for (const [prop, decl] of block.decls) {
-        remaining.set(`${ck}\0${prop}`, String(decl.value));
+        remaining.set(`${ck} ${prop}`, String(decl.value));
       }
     }
     if (remaining.size === 0) return { classes: [], exact: true, warnings: [] };
@@ -3498,6 +4803,15 @@ var CustomCSSResolver = class {
     }
     return { classes, exact: remaining.size === 0, warnings: [] };
   }
+  /**
+   * Return a CSS stylesheet defining the given class tokens, so a verifier can render a subtree with
+   * the project's real styling applied. The source stylesheets ARE the definition, so we hand back
+   * their concatenation verbatim (every relevant rule — including combinator/structural selectors —
+   * is preserved). `classes` is accepted for interface parity but the full source is always returned.
+   */
+  cssFor(_classes) {
+    return this.#files.map((f) => f.css).join("\n");
+  }
   selectorUsage(token) {
     const u2 = this.#usage.get(token);
     if (!u2) {
@@ -3682,87 +4996,79 @@ var CustomCSSResolver = class {
     if (this.#reverse) return this.#reverse;
     const out = [];
     for (const token of this.#classIndex.keys()) {
-      const styles = this.#resolveTokens([token], [token]);
-      const keyed = /* @__PURE__ */ new Map();
-      for (const [ck, block] of styles.blocks) {
-        for (const [prop, decl] of block.decls) keyed.set(`${ck}\0${prop}`, String(decl.value));
-      }
-      if (keyed.size > 0) out.push({ token, keyed });
-    }
-    out.sort((a, b3) => b3.keyed.size - a.keyed.size);
-    this.#reverse = out;
-    return out;
-  }
-};
-function createCssResolver(cssFiles = [], options) {
-  return new CustomCSSResolver(cssFiles, options);
-}
-function splitCompounds(selector) {
-  const compounds = [];
-  let current = [];
-  let leftCombinator = null;
-  for (const node of selector.nodes) {
-    if (sp.isCombinator(node)) {
-      compounds.push({ leftCombinator, nodes: current });
-      current = [];
-      leftCombinator = combinatorValue(node);
-    } else {
-      current.push(node);
+      const styles = this.#resolveTokens([token], [token]);
+      const keyed = /* @__PURE__ */ new Map();
+      for (const [ck, block] of styles.blocks) {
+        for (const [prop, decl] of block.decls) keyed.set(`${ck} ${prop}`, String(decl.value));
+      }
+      if (keyed.size > 0) out.push({ token, keyed });
     }
+    out.sort((a, b3) => b3.keyed.size - a.keyed.size);
+    this.#reverse = out;
+    return out;
   }
-  compounds.push({ leftCombinator, nodes: current });
-  return compounds;
-}
-function combinatorValue(node) {
-  const v2 = node.value;
-  return v2.trim() === "" ? " " : v2.trim();
-}
-function pseudoName(node) {
-  return node.value.toLowerCase();
-}
-function isPseudoElement(node) {
-  return sp.isPseudoElement(node) || LEGACY_PSEUDO_ELEMENTS.has(pseudoName(node));
-}
-function normalizePseudoElement(node) {
-  const name = pseudoName(node);
-  return name.startsWith("::") ? name : `::${name.replace(/^:/, "")}`;
+};
+function createCssResolver(cssFiles = [], options) {
+  return new CustomCSSResolver(cssFiles, options);
 }
-function mediaContext(rule) {
-  const parts = [];
-  let skip = false;
-  let parent = rule.parent;
-  while (parent && parent.type === "atrule") {
-    const at = parent;
-    const name = at.name.toLowerCase();
-    if (name === "media") parts.unshift(at.params.trim().replace(/\s+/g, " "));
-    else if (name === "keyframes" || name.endsWith("keyframes") || name === "font-face") skip = true;
-    parent = parent.parent;
+
+// ../resolver-tailwind/src/index.ts
+init_cjs_shims();
+
+// ../resolver-tailwind/src/tailwind/resolver.ts
+init_cjs_shims();
+
+// ../resolver-tailwind/src/tailwind/emit.ts
+init_cjs_shims();
+
+// ../resolver-tailwind/src/tailwind/fingerprint.ts
+init_cjs_shims();
+function fnv1a(input) {
+  let h2 = 2166136261;
+  for (let i = 0; i < input.length; i += 1) {
+    h2 ^= input.charCodeAt(i);
+    h2 = Math.imul(h2, 16777619);
   }
-  return { media: parts.join(" and "), skip };
+  return (h2 >>> 0).toString(16).padStart(8, "0");
 }
-function collectDecls(rule) {
-  const out = [];
-  for (const node of rule.nodes) {
-    if (node.type === "decl") out.push([node.prop, node.value, node.important === true]);
+
+// ../resolver-tailwind/src/tailwind/emit.ts
+function expandForEmit(norm, prop, value, important) {
+  const pairsFor = (p2, v2) => norm.normalizeDeclaration(p2, v2, important).map((d3) => [d3.property, String(d3.value)]);
+  if (prop === "size") {
+    return [...pairsFor("width", value), ...pairsFor("height", value)];
   }
-  return out;
-}
-function isPlainClassToken(token) {
-  return token.length > 0 && !/[\s.#>+~:[\]()]/.test(token);
+  if (prop === "inset-block" || prop === "inset-inline") {
+    const parts = value.split(/\s+/).filter((s) => s.length > 0);
+    const a = parts[0] ?? value;
+    const b3 = parts[1] ?? a;
+    const sides = prop === "inset-block" ? ["top", "bottom"] : ["left", "right"];
+    return [...pairsFor(sides[0], a), ...pairsFor(sides[1], b3)];
+  }
+  return pairsFor(prop, value);
 }
-function readCssPath(path6) {
+function synthesizeResidual(remaining, ctx) {
+  if (remaining.size === 0) return void 0;
+  const norm = ctx.normalizer ?? normalizer;
+  const decls = /* @__PURE__ */ new Map();
+  for (const [prop, value] of remaining) {
+    for (const decl of norm.normalizeDeclaration(String(prop), value, false)) {
+      decls.set(decl.property, decl);
+    }
+  }
+  const block = { condition: BASE_CONDITION, decls };
+  const styleMap = { blocks: /* @__PURE__ */ new Map([[conditionKey(BASE_CONDITION), block]]) };
+  const css = [...remaining].map(([p2, v2]) => `${p2}:${v2}`).join(";");
+  const className = `df-${fnv1a(css)}`;
+  const synthetic = { className, decls: styleMap, css: `.${className}{${css}}` };
   try {
-    return { id: path6, css: (0, import_node_fs.readFileSync)(path6, "utf8") };
-  } catch (cause) {
-    throw new Error(`resolver-css: cannot read CSS file "${path6}"`, { cause });
+    ctx.sink.register(synthetic);
+  } catch {
   }
-}
-function deriveFingerprint(provider, files) {
-  const parts = files.map((f) => `${f.id}:${f.css.length}`).sort();
-  return `${provider}/${ENGINE_VERSION}::${parts.join("|")}`;
+  return synthetic;
 }
 
-// ../resolver-tailwind/src/index.ts
+// ../resolver-tailwind/src/tailwind/engine.ts
 init_cjs_shims();
 var import_node_module2 = require("module");
 var path3 = __toESM(require("path"), 1);
@@ -3811,6 +5117,12 @@ function loadEngine(options) {
     return null;
   }
 }
+
+// ../resolver-tailwind/src/tailwind/extract.ts
+init_cjs_shims();
+
+// ../resolver-tailwind/src/tailwind/selector.ts
+init_cjs_shims();
 var LEGACY_PSEUDO_ELEMENTS2 = /* @__PURE__ */ new Set([
   ":before",
   ":after",
@@ -3857,6 +5169,26 @@ function makeCondition(media, states, pseudoElement) {
     pseudoElement
   };
 }
+function unescapeClass(selector) {
+  const sel = selector.trim();
+  if (sel[0] !== ".") return null;
+  let out = "";
+  for (let i = 1; i < sel.length; i += 1) {
+    const c = sel[i];
+    if (c === "\\") {
+      i += 1;
+      if (i < sel.length) out += sel[i];
+      continue;
+    }
+    if (c === ":" || c === "." || c === "[" || c === " " || c === ">" || c === "+" || c === "~" || c === ",") {
+      return null;
+    }
+    out += c;
+  }
+  return out.length > 0 ? out : null;
+}
+
+// ../resolver-tailwind/src/tailwind/extract.ts
 function collectRules(node, mediaStack, inUnsupportedAtRule, out) {
   if (node.type === "rule") {
     out.push({ rule: node, media: mediaStack, unsupported: inUnsupportedAtRule });
@@ -3896,9 +5228,33 @@ function extractToken(token, nodes) {
     const mediaQuery = media.join(" and ");
     blocks.push({ condition: makeCondition(mediaQuery, parsed.states, parsed.pseudoElement), decls });
   }
-  const opaque = sawComplex && blocks.length === 0 ? { token, reason: "combinator-variant", detail: "utility targets descendants/siblings, not its own box" } : void 0;
-  return { blocks, produced: true, opaque };
+  const opaque2 = sawComplex && blocks.length === 0 ? { token, reason: "combinator-variant", detail: "utility targets descendants/siblings, not its own box" } : void 0;
+  return { blocks, produced: true, opaque: opaque2 };
+}
+
+// ../resolver-tailwind/src/tailwind/serialize.ts
+init_cjs_shims();
+function serializeCssNode(node) {
+  if (node.type === "decl") {
+    const d3 = node;
+    if (typeof d3.value !== "string") return "";
+    return `${d3.prop}:${d3.value}${d3.important === true ? " !important" : ""}`;
+  }
+  if (node.type === "rule") {
+    const r2 = node;
+    const body = (r2.nodes ?? []).map((c) => serializeCssNode(c)).filter((s) => s.length > 0).join(";");
+    return `${r2.selector}{${body}}`;
+  }
+  if (node.type === "atrule") {
+    const a = node;
+    const body = (a.nodes ?? []).map((c) => serializeCssNode(c)).filter((s) => s.length > 0).join("");
+    return `@${a.name} ${a.params}{${body}}`;
+  }
+  return "";
 }
+
+// ../resolver-tailwind/src/tailwind/stylemap.ts
+init_cjs_shims();
 function buildStyleMap(blockMaps) {
   if (blockMaps.size === 0) return emptyStyleMap();
   const blocks = /* @__PURE__ */ new Map();
@@ -3921,6 +5277,9 @@ function shadowedBy(prev) {
   add(prev.origin);
   return out.length > 0 ? out : void 0;
 }
+
+// ../resolver-tailwind/src/tailwind/usage.ts
+init_cjs_shims();
 var OPAQUE_USAGE = {
   asSubject: true,
   asAncestor: true,
@@ -3939,14 +5298,8 @@ var DROPPABLE_USAGE = {
   asStructural: false,
   droppable: true
 };
-function fnv1a(input) {
-  let h2 = 2166136261;
-  for (let i = 0; i < input.length; i += 1) {
-    h2 ^= input.charCodeAt(i);
-    h2 = Math.imul(h2, 16777619);
-  }
-  return (h2 >>> 0).toString(16).padStart(8, "0");
-}
+
+// ../resolver-tailwind/src/tailwind/resolver.ts
 var TailwindResolver = class {
   id = "tailwind";
   provider;
@@ -3992,14 +5345,14 @@ var TailwindResolver = class {
     const blockMaps = /* @__PURE__ */ new Map();
     const resolved = [];
     const unknown = [];
-    const opaque = [];
+    const opaque2 = [];
     input.classes.forEach((token, tokenIndex) => {
       const extracted = this.#extract(token);
       if (!extracted.produced) {
         unknown.push(token);
         return;
       }
-      if (extracted.opaque) opaque.push(extracted.opaque);
+      if (extracted.opaque) opaque2.push(extracted.opaque);
       if (extracted.blocks.length === 0) return;
       const origin = { kind: "class", tokenIndex, className: token };
       let contributed = false;
@@ -4025,7 +5378,7 @@ var TailwindResolver = class {
       styles: buildStyleMap(blockMaps),
       resolved,
       unknown,
-      opaque,
+      opaque: opaque2,
       warnings: []
     };
     this.#resolveCache.set(key, result);
@@ -4121,6 +5474,21 @@ var TailwindResolver = class {
     const residual = synthesizeResidual(remaining, ctx);
     return residual ? { classes, residual, exact, warnings: [] } : { classes, exact, warnings: [] };
   }
+  /**
+   * Generate a CSS stylesheet that defines `classes`, so a verifier can render a subtree with the
+   * real Tailwind styling applied. Backed by the same engine `resolve` uses (`generate(candidates)`),
+   * serialized to plain CSS. Returns `''` when the engine is unavailable or generates nothing.
+   */
+  cssFor(classes) {
+    if (!this.#engine) return "";
+    const tokens = [...new Set(classes)].filter((c) => c.length > 0);
+    if (tokens.length === 0) return "";
+    try {
+      return this.#engine.generate(tokens).map((n) => serializeCssNode(n)).filter((s) => s.length > 0).join("\n");
+    } catch {
+      return "";
+    }
+  }
   selectorUsage(token) {
     const ex = this.#extract(token);
     if (!ex.produced || ex.opaque) return OPAQUE_USAGE;
@@ -4129,58 +5497,6 @@ var TailwindResolver = class {
     return DROPPABLE_USAGE;
   }
 };
-function expandForEmit(norm, prop, value, important) {
-  const pairsFor = (p2, v2) => norm.normalizeDeclaration(p2, v2, important).map((d3) => [d3.property, String(d3.value)]);
-  if (prop === "size") {
-    return [...pairsFor("width", value), ...pairsFor("height", value)];
-  }
-  if (prop === "inset-block" || prop === "inset-inline") {
-    const parts = value.split(/\s+/).filter((s) => s.length > 0);
-    const a = parts[0] ?? value;
-    const b3 = parts[1] ?? a;
-    const sides = prop === "inset-block" ? ["top", "bottom"] : ["left", "right"];
-    return [...pairsFor(sides[0], a), ...pairsFor(sides[1], b3)];
-  }
-  return pairsFor(prop, value);
-}
-function synthesizeResidual(remaining, ctx) {
-  if (remaining.size === 0) return void 0;
-  const norm = ctx.normalizer ?? normalizer;
-  const decls = /* @__PURE__ */ new Map();
-  for (const [prop, value] of remaining) {
-    for (const decl of norm.normalizeDeclaration(String(prop), value, false)) {
-      decls.set(decl.property, decl);
-    }
-  }
-  const block = { condition: BASE_CONDITION, decls };
-  const styleMap = { blocks: /* @__PURE__ */ new Map([[conditionKey(BASE_CONDITION), block]]) };
-  const css = [...remaining].map(([p2, v2]) => `${p2}:${v2}`).join(";");
-  const className = `df-${fnv1a(css)}`;
-  const synthetic = { className, decls: styleMap, css: `.${className}{${css}}` };
-  try {
-    ctx.sink.register(synthetic);
-  } catch {
-  }
-  return synthetic;
-}
-function unescapeClass(selector) {
-  const sel = selector.trim();
-  if (sel[0] !== ".") return null;
-  let out = "";
-  for (let i = 1; i < sel.length; i += 1) {
-    const c = sel[i];
-    if (c === "\\") {
-      i += 1;
-      if (i < sel.length) out += sel[i];
-      continue;
-    }
-    if (c === ":" || c === "." || c === "[" || c === " " || c === ">" || c === "+" || c === "~" || c === ",") {
-      return null;
-    }
-    out += c;
-  }
-  return out.length > 0 ? out : null;
-}
 function createTailwindResolver(config) {
   return new TailwindResolver(config);
 }
@@ -4255,66 +5571,68 @@ function createTransform(options) {
   const projectRoot = options.projectRoot ?? process.cwd();
   const resolver = buildResolver(options.provider, options.css, projectRoot);
   const patterns = selectPatterns(options.passes);
+  function prepare(code, id, kind, gate) {
+    const parsed = createJsxFrontend().parse(code, {
+      id,
+      kind,
+      resolver,
+      normalizer,
+      config: {},
+      onDiagnostic: () => {
+      }
+    });
+    const doc = parsed.doc;
+    const nodesIn = doc.nodes.size;
+    for (const node of doc.nodes.values()) node.meta.safetyFloor = 3;
+    const ctx = {
+      doc,
+      safetyCeiling: options.safety,
+      normalizer,
+      // Real CSS-selector-safety index from the active resolver (custom-CSS reports combinator /
+      // structural-pseudo coupling; Tailwind has none → null index, behaviour unchanged).
+      selectors: buildSelectorIndex(doc, resolver),
+      resolver,
+      gate
+    };
+    return { doc, ctx, passes: buildPasses(patterns), nodesIn };
+  }
+  function finish(code, optimized, id, nodesIn) {
+    syncClassesFromComputed(optimized, resolver, normalizer);
+    const printed = createJsxBackend().print(
+      optimized,
+      { moduleId: id, ops: [], provenance: /* @__PURE__ */ new Map() },
+      { normalizer, resolver, sink: createSyntheticSink(), eol: "\n", onDiagnostic: () => {
+      } }
+    );
+    const out = printed.code;
+    const nodesOut = optimized.nodes.size;
+    const classesBefore = countClassTokens(code);
+    const classesAfter = countClassTokens(out);
+    return {
+      code: out,
+      changed: out !== code,
+      passthrough: false,
+      stats: {
+        nodesIn,
+        nodesOut,
+        nodesRemoved: Math.max(0, nodesIn - nodesOut),
+        classesBefore,
+        classesAfter,
+        classesSaved: Math.max(0, classesBefore - classesAfter),
+        bytesBefore: bytes(code),
+        bytesAfter: bytes(out),
+        bytesSaved: bytes(code) - bytes(out)
+      }
+    };
+  }
   return {
     resolver,
     transformFile(code, id) {
       const kind = jsxKindOf(id);
       if (kind === null) return passthroughResult(code);
-      const parsed = createJsxFrontend().parse(code, {
-        id,
-        kind,
-        resolver,
-        normalizer,
-        config: {},
-        onDiagnostic: () => {
-        }
-      });
-      const doc = parsed.doc;
-      const nodesIn = doc.nodes.size;
-      for (const node of doc.nodes.values()) node.meta.safetyFloor = 3;
-      const ctx = {
-        doc,
-        safetyCeiling: options.safety,
-        normalizer,
-        // Real CSS-selector-safety index from the active resolver (custom-CSS reports combinator /
-        // structural-pseudo coupling; Tailwind has none → null index, behaviour unchanged).
-        selectors: buildSelectorIndex(doc, resolver),
-        resolver
-      };
-      const { doc: optimized } = runPasses(doc, buildPasses(patterns), ctx);
-      syncClassesFromComputed(optimized, resolver, normalizer);
-      const printed = createJsxBackend().print(
-        optimized,
-        { moduleId: id, ops: [], provenance: /* @__PURE__ */ new Map() },
-        {
-          normalizer,
-          resolver,
-          sink: createSyntheticSink(),
-          eol: "\n",
-          onDiagnostic: () => {
-          }
-        }
-      );
-      const out = printed.code;
-      const nodesOut = optimized.nodes.size;
-      const classesBefore = countClassTokens(code);
-      const classesAfter = countClassTokens(out);
-      return {
-        code: out,
-        changed: out !== code,
-        passthrough: false,
-        stats: {
-          nodesIn,
-          nodesOut,
-          nodesRemoved: Math.max(0, nodesIn - nodesOut),
-          classesBefore,
-          classesAfter,
-          classesSaved: Math.max(0, classesBefore - classesAfter),
-          bytesBefore: bytes(code),
-          bytesAfter: bytes(out),
-          bytesSaved: bytes(code) - bytes(out)
-        }
-      };
+      const { doc, ctx, passes, nodesIn } = prepare(code, id, kind, "provably-safe");
+      const { doc: optimized } = runPasses(doc, passes, ctx);
+      return finish(code, optimized, id, nodesIn);
     }
   };
 }
@@ -4995,19 +6313,112 @@ ${import_picocolors2.default.gray(d2)}  ${t}
 };
 var J2 = `${import_picocolors2.default.gray(o)}  `;
 
+// ../cli/src/detect.ts
+init_cjs_shims();
+var fs2 = __toESM(require("fs"), 1);
+var path5 = __toESM(require("path"), 1);
+var SKIP_DIRS2 = /* @__PURE__ */ new Set([
+  "node_modules",
+  "dist",
+  "build",
+  ".next",
+  "out",
+  "coverage",
+  ".git",
+  "domflax-out"
+]);
+var COMMON_INPUT_DIRS = ["src", "app", "components", "pages", "lib", "ui", "public"];
+var CSS_FILE_CAP = 200;
+function toRelative(root, abs) {
+  const rel = path5.relative(root, abs);
+  return rel.split(path5.sep).join("/");
+}
+function detectCssFiles(root) {
+  const found = [];
+  let capped = false;
+  const walk = (dir) => {
+    if (capped) return;
+    let entries;
+    try {
+      entries = fs2.readdirSync(dir, { withFileTypes: true });
+    } catch {
+      return;
+    }
+    for (const entry of entries) {
+      const full = path5.join(dir, entry.name);
+      if (entry.isDirectory()) {
+        if (SKIP_DIRS2.has(entry.name)) continue;
+        walk(full);
+        if (capped) return;
+      } else if (entry.isFile() && entry.name.toLowerCase().endsWith(".css")) {
+        found.push(toRelative(root, full));
+        if (found.length >= CSS_FILE_CAP) {
+          capped = true;
+          return;
+        }
+      }
+    }
+  };
+  walk(path5.resolve(root));
+  found.sort((a, b3) => a.localeCompare(b3));
+  if (capped) {
+    console.error(`domflax: more than ${CSS_FILE_CAP} CSS files found; showing the first ${CSS_FILE_CAP}.`);
+  }
+  return found;
+}
+function detectInputDirs(root) {
+  const resolved = path5.resolve(root);
+  return COMMON_INPUT_DIRS.filter((name) => {
+    try {
+      return fs2.statSync(path5.join(resolved, name)).isDirectory();
+    } catch {
+      return false;
+    }
+  });
+}
+
 // ../cli/src/wizard.ts
+var OTHER_INPUT = "\0domflax.other";
 var WIZARD_CANCELLED = /* @__PURE__ */ Symbol("domflax.wizard.cancelled");
 function cancelled(value) {
   return pD(value);
 }
 async function runWizard(base) {
   Ie("domflax \u2014 optimize your markup");
-  const pathInput = await he({
-    message: "Which folder, glob, or file should domflax optimize?",
-    placeholder: "src",
-    defaultValue: "src"
-  });
-  if (cancelled(pathInput)) return done();
+  const root = base.projectRoot ?? process.cwd();
+  const detectedInputs = detectInputDirs(root);
+  let inputPath;
+  if (detectedInputs.length > 0) {
+    const defaultInput = detectedInputs.includes("src") ? "src" : detectedInputs[0];
+    const choice = await ve({
+      message: "Which folder should domflax optimize?",
+      options: [
+        ...detectedInputs.map((dir) => ({ value: dir, label: dir, hint: "detected" })),
+        { value: OTHER_INPUT, label: "Other (type a path)\u2026" }
+      ],
+      initialValue: defaultInput
+    });
+    if (cancelled(choice)) return done();
+    if (choice === OTHER_INPUT) {
+      const typed = await he({
+        message: "Which folder, glob, or file should domflax optimize?",
+        placeholder: "src",
+        defaultValue: "src"
+      });
+      if (cancelled(typed)) return done();
+      inputPath = String(typed);
+    } else {
+      inputPath = String(choice);
+    }
+  } else {
+    const typed = await he({
+      message: "Which folder, glob, or file should domflax optimize?",
+      placeholder: "src",
+      defaultValue: "src"
+    });
+    if (cancelled(typed)) return done();
+    inputPath = String(typed);
+  }
   const outputMode = await ve({
     message: "Where should the optimized files go?",
     options: [
@@ -5056,17 +6467,29 @@ async function runWizard(base) {
   if (cancelled(provider)) return done();
   let css = base.css;
   if (provider === "custom") {
-    const cssInput = await he({
-      message: "CSS files (space-separated):",
-      placeholder: "src/styles.css"
-    });
-    if (cancelled(cssInput)) return done();
-    css = String(cssInput).split(/\s+/).filter((s) => s.length > 0);
+    const detectedCss = detectCssFiles(root);
+    if (detectedCss.length > 0) {
+      const picked = await fe({
+        message: "Which CSS files should resolve your classes? (all detected files are pre-selected)",
+        options: detectedCss.map((file) => ({ value: file, label: file })),
+        initialValues: [...detectedCss],
+        required: false
+      });
+      if (cancelled(picked)) return done();
+      css = picked;
+    } else {
+      const cssInput = await he({
+        message: "CSS files (space-separated):",
+        placeholder: "src/styles.css"
+      });
+      if (cancelled(cssInput)) return done();
+      css = String(cssInput).split(/\s+/).filter((s) => s.length > 0);
+    }
   }
   Se("Ready \u2014 running domflax.");
   return {
     ...base,
-    paths: [String(pathInput)],
+    paths: [inputPath],
     out,
     provider,
     css,
@@ -5098,7 +6521,7 @@ function printReport(totals) {
   console.log(`  classes saved   : ${totals.classesSaved}`);
   console.log(`  bytes saved     : ${totals.bytesSaved}`);
 }
-function execute(options) {
+async function execute(options) {
   const { files, inputRoot, warnings } = discoverInputs(options.paths);
   for (const w2 of warnings) console.error(`domflax: ${w2}`);
   if (files.length === 0) {
@@ -5128,7 +6551,7 @@ function execute(options) {
     const result = transform.transformFile(code, file);
     addStats(totals, result.stats, result.changed);
     if (options.dryRun) {
-      const rel = path5.relative(inputRoot, file) || path5.basename(file);
+      const rel = path6.relative(inputRoot, file) || path6.basename(file);
       if (result.changed) console.log(unifiedDiff(code, result.code, rel));
       else if (!options.report) console.log(`  (unchanged) ${rel}`);
       continue;
@@ -5141,9 +6564,9 @@ function execute(options) {
       continue;
     }
     try {
-      (0, import_node_fs2.mkdirSync)(path5.dirname(target.value), { recursive: true });
+      (0, import_node_fs2.mkdirSync)(path6.dirname(target.value), { recursive: true });
       (0, import_node_fs2.writeFileSync)(target.value, result.code, "utf8");
-      console.log(`domflax: wrote ${path5.relative(process.cwd(), target.value) || target.value}`);
+      console.log(`domflax: wrote ${path6.relative(process.cwd(), target.value) || target.value}`);
     } catch (err) {
       console.error(`domflax: cannot write ${target.value}: ${String(err?.message ?? err)}`);
       failures += 1;
@@ -5180,27 +6603,13 @@ async function main(argv = process.argv.slice(2)) {
     return;
   }
   try {
-    const result = execute(options);
+    const result = await execute(options);
     process.exitCode = result.exitCode;
   } catch (err) {
     console.error(`domflax: ${err instanceof Error ? err.message : String(err)}`);
     process.exitCode = 1;
   }
 }
-function isMainEntry() {
-  const entry = process.argv[1];
-  if (entry === void 0) return false;
-  try {
-    const self = path5.resolve((0, import_node_url.fileURLToPath)(importMetaUrl));
-    const argv = path5.resolve(entry);
-    return process.platform === "win32" ? self.toLowerCase() === argv.toLowerCase() : self === argv;
-  } catch {
-    return false;
-  }
-}
-if (isMainEntry()) {
-  void main();
-}
 
 // src/cli.ts
 main(process.argv.slice(2));