domflax 0.1.1 → 0.1.4

package/dist/cli.cjs

@@ -175,8 +175,8 @@ init_cjs_shims();
 
 // ../cli/src/index.ts
 init_cjs_shims();
-var import_node_fs2 = require("fs");
-var path6 = __toESM(require("path"), 1);
+var import_node_fs4 = require("fs");
+var path9 = __toESM(require("path"), 1);
 
 // ../cli/src/options.ts
 init_cjs_shims();
@@ -192,6 +192,14 @@ function toSafety(raw) {
   if (n === 0 || n === 1 || n === 2 || n === 3) return n;
   throw new Error(`domflax: invalid --safety "${raw}" (expected 0, 1, 2 or 3)`);
 }
+function toPositiveInt(raw, flag) {
+  if (raw === void 0) return null;
+  const n = Number(raw);
+  if (!Number.isInteger(n) || n < 1) {
+    throw new Error(`domflax: invalid ${flag} "${raw}" (expected a positive integer)`);
+  }
+  return n;
+}
 function parseInvocation(argv) {
   const { values, positionals } = (0, import_node_util.parseArgs)({
     args: argv,
@@ -207,7 +215,9 @@ function parseInvocation(argv) {
       "no-interactive": { type: "boolean", default: false },
       yes: { type: "boolean", short: "y", default: false },
       safety: { type: "string" },
-      "project-root": { type: "string" }
+      "project-root": { type: "string" },
+      "max-memory": { type: "string" },
+      concurrency: { type: "string" }
     }
   });
   const provider = values.provider ?? DEFAULT_PROVIDER;
@@ -226,7 +236,9 @@ function parseInvocation(argv) {
     interactive: values["no-interactive"] !== true && values.yes !== true,
     passes: null,
     safety: toSafety(values.safety),
-    projectRoot: values["project-root"] ?? null
+    projectRoot: values["project-root"] ?? null,
+    maxMemory: toPositiveInt(values["max-memory"], "--max-memory"),
+    concurrency: toPositiveInt(values.concurrency, "--concurrency")
   };
 }
 function shouldPrompt(options, isTty) {
@@ -250,18 +262,212 @@ var USAGE = [
   "  --dangerously-overwrite-source overwrite source in place (needs a clean git tree)",
   "  --no-git-check                 skip the clean-git-tree gate",
   "  --safety <0|1|2|3>             optimization aggressiveness (default: 2)",
+  "  --max-memory <MB>              memory budget; caps pool RAM AND parallelism (default: ~70% free RAM)",
+  "  --concurrency <N>              max parallel workers (still clamped by --max-memory)",
   "  --yes, --no-interactive        never launch the wizard (CI-safe)",
   "",
+  "Many files are processed across CPU cores by a memory-bounded worker pool; small jobs run inline.",
   "With no paths in an interactive terminal, a guided wizard launches."
 ].join("\n");
 
+// ../cli/src/pool.ts
+init_cjs_shims();
+var import_node_fs = require("fs");
+var os = __toESM(require("os"), 1);
+var path = __toESM(require("path"), 1);
+var import_node_url = require("url");
+var import_node_worker_threads = require("worker_threads");
+var PER_WORKER_MB = 160;
+var MIN_OLD_GEN_MB = 64;
+function emptyTotals() {
+  return { files: 0, changed: 0, nodesRemoved: 0, classesSaved: 0, bytesSaved: 0 };
+}
+function addStats(totals, stats, changed) {
+  totals.files += 1;
+  if (changed) totals.changed += 1;
+  totals.nodesRemoved += stats.nodesRemoved;
+  totals.classesSaved += stats.classesSaved;
+  totals.bytesSaved += stats.bytesSaved;
+}
+function clamp(n, lo, hi) {
+  return Math.max(lo, Math.min(hi, n));
+}
+function computeWorkerCount(options) {
+  const cpus2 = Math.max(1, os.cpus().length);
+  const freeMB = Math.floor(os.freemem() / (1024 * 1024));
+  const budgetMB = Math.max(PER_WORKER_MB, options.maxMemory ?? Math.floor(freeMB * 0.7));
+  const byMemory = Math.max(1, Math.floor(budgetMB / PER_WORKER_MB));
+  const target = options.concurrency ?? Math.max(1, cpus2 - 1);
+  const workers = clamp(Math.min(target, byMemory), 1, byMemory);
+  const perWorkerCapMB = Math.max(MIN_OLD_GEN_MB, Math.floor(budgetMB / workers));
+  return { workers, budgetMB, perWorkerCapMB };
+}
+function inlineThreshold(workers) {
+  return Math.max(4, 2 * workers);
+}
+function shouldUsePool(fileCount, plan) {
+  return plan.workers > 1 && fileCount > inlineThreshold(plan.workers);
+}
+function moduleDir() {
+  try {
+    return path.dirname((0, import_node_url.fileURLToPath)(importMetaUrl));
+  } catch {
+    return typeof __dirname !== "undefined" ? __dirname : process.cwd();
+  }
+}
+function resolveWorkerPath() {
+  const dir = moduleDir();
+  const candidates = [
+    path.join(dir, "worker.cjs"),
+    path.join(dir, "worker.js"),
+    path.join(dir, "..", "dist", "worker.cjs"),
+    path.join(dir, "..", "dist", "worker.js")
+  ];
+  for (const c of candidates) {
+    if ((0, import_node_fs.existsSync)(c)) return c;
+  }
+  return candidates[0];
+}
+function runPool(files, init, plan, onWrote) {
+  const workerPath = resolveWorkerPath();
+  const totals = emptyTotals();
+  const wrote = [];
+  const errors = [];
+  let failures = 0;
+  const budgetBytes = plan.budgetMB * 1024 * 1024;
+  let nextIndex = 0;
+  let completed = 0;
+  const total = files.length;
+  let respawns = 0;
+  const maxRespawns = total + plan.workers + 8;
+  return new Promise((resolve6) => {
+    const handles = /* @__PURE__ */ new Set();
+    const finishIfDone = () => {
+      if (completed < total) return;
+      for (const h2 of handles) {
+        if (!h2.dead) {
+          try {
+            h2.worker.postMessage({ type: "stop" });
+          } catch {
+          }
+          void h2.worker.terminate();
+        }
+      }
+      handles.clear();
+      resolve6({ totals, failures, wrote, errors });
+    };
+    const recordFailure = (file, error) => {
+      failures += 1;
+      completed += 1;
+      errors.push({ path: file, error });
+    };
+    const dispatch = (h2) => {
+      if (h2.dead) return;
+      if (nextIndex >= total) {
+        h2.current = null;
+        try {
+          h2.worker.postMessage({ type: "stop" });
+        } catch {
+        }
+        return;
+      }
+      if (process.memoryUsage().rss > budgetBytes) {
+        setTimeout(() => dispatch(h2), 25);
+        return;
+      }
+      const file = files[nextIndex++];
+      h2.current = file;
+      try {
+        h2.worker.postMessage({ type: "file", path: file });
+      } catch {
+        onWorkerDown(h2);
+      }
+    };
+    const onMessage = (h2, msg) => {
+      if (msg.type === "ready") {
+        h2.ready = true;
+        dispatch(h2);
+        return;
+      }
+      h2.current = null;
+      if (msg.ok) {
+        addStats(totals, msg.stats, msg.changed);
+        if (msg.wrote) {
+          wrote.push(msg.wrote);
+          onWrote?.(msg.wrote);
+        }
+      } else {
+        failures += 1;
+        errors.push({ path: msg.path, error: msg.error });
+      }
+      completed += 1;
+      if (completed >= total) {
+        finishIfDone();
+        return;
+      }
+      dispatch(h2);
+    };
+    const drainRemaining = (reason) => {
+      while (nextIndex < total) recordFailure(files[nextIndex++], reason);
+      finishIfDone();
+    };
+    const onWorkerDown = (h2) => {
+      if (h2.dead) return;
+      h2.dead = true;
+      handles.delete(h2);
+      const lost = h2.current;
+      h2.current = null;
+      if (lost !== null) recordFailure(lost, "worker crashed while processing this file");
+      void h2.worker.terminate();
+      if (completed >= total) {
+        finishIfDone();
+        return;
+      }
+      if (nextIndex >= total) {
+        if (handles.size === 0) finishIfDone();
+        return;
+      }
+      if (respawns < maxRespawns) {
+        respawns += 1;
+        spawn();
+      } else if (handles.size === 0) {
+        drainRemaining("worker pool exhausted its respawn budget (memory cap too small?)");
+      }
+    };
+    const spawn = () => {
+      let worker;
+      try {
+        worker = new import_node_worker_threads.Worker(workerPath, {
+          workerData: init,
+          resourceLimits: { maxOldGenerationSizeMb: plan.perWorkerCapMB }
+        });
+      } catch {
+        if (nextIndex < total) recordFailure(files[nextIndex++], "failed to spawn worker");
+        if (completed >= total) finishIfDone();
+        else if (handles.size === 0 && nextIndex < total) spawn();
+        return;
+      }
+      const h2 = { worker, current: null, ready: false, dead: false };
+      handles.add(h2);
+      worker.on("message", (m2) => onMessage(h2, m2));
+      worker.on("error", () => onWorkerDown(h2));
+      worker.on("exit", (code) => {
+        if (code !== 0) onWorkerDown(h2);
+      });
+    };
+    const initial = Math.min(plan.workers, total);
+    for (let i = 0; i < initial; i++) spawn();
+    if (initial === 0) finishIfDone();
+  });
+}
+
 // ../cli/src/safety.ts
 init_cjs_shims();
 var import_node_child_process = require("child_process");
-var path = __toESM(require("path"), 1);
+var path2 = __toESM(require("path"), 1);
 var DISPOSABLE_DIRS = /* @__PURE__ */ new Set(["dist", "build", "out", ".next"]);
 function isDisposablePath(file) {
-  return path.resolve(file).split(path.sep).some((seg) => DISPOSABLE_DIRS.has(seg));
+  return path2.resolve(file).split(path2.sep).some((seg) => DISPOSABLE_DIRS.has(seg));
 }
 function isGitClean(cwd) {
   try {
@@ -285,19 +491,19 @@ function planWrites(options, gitClean) {
     }
     return { ok: true, value: { mode: "overwrite-source", outDir: null } };
   }
-  const outDir = path.resolve(options.out ?? "domflax-out");
+  const outDir = path2.resolve(options.out ?? "domflax-out");
   return { ok: true, value: { mode: "out-dir", outDir } };
 }
 function destinationFor(file, inputRoot, plan) {
-  const absFile = path.resolve(file);
+  const absFile = path2.resolve(file);
   if (plan.mode === "overwrite-source") {
     return { ok: true, value: absFile };
   }
   const outDir = plan.outDir;
-  const rel = path.relative(inputRoot, absFile);
-  const safeRel = rel === "" || rel.startsWith("..") || path.isAbsolute(rel) ? path.basename(absFile) : rel;
-  const dest = path.join(outDir, safeRel);
-  if (path.resolve(dest) === absFile && !isDisposablePath(absFile)) {
+  const rel = path2.relative(inputRoot, absFile);
+  const safeRel = rel === "" || rel.startsWith("..") || path2.isAbsolute(rel) ? path2.basename(absFile) : rel;
+  const dest = path2.join(outDir, safeRel);
+  if (path2.resolve(dest) === absFile && !isDisposablePath(absFile)) {
     return {
       ok: false,
       error: `refusing to overwrite source file ${absFile}: the output path resolves onto the source. Choose a different --out, or pass --dangerously-overwrite-source (with a clean git tree).`
@@ -382,6 +588,7 @@ function defaultMeta(safetyFloor = 0) {
     declaresCustomProperties: false,
     whitespaceSensitive: false,
     touched: false,
+    styleDirty: false,
     synthetic: false,
     safetyFloor
   };
@@ -566,6 +773,14 @@ function markTouched(state, id) {
     state.touched.add(id);
   }
 }
+function markStyleDirty(state, id) {
+  const n = state.doc.nodes.get(id);
+  if (n) {
+    n.meta.touched = true;
+    n.meta.styleDirty = true;
+    state.touched.add(id);
+  }
+}
 function removeSubtree(state, id) {
   const node = state.doc.nodes.get(id);
   if (!node) return;
@@ -858,7 +1073,7 @@ function applyOne(state, op) {
         return [precond(op, op.target, "setClassList target is not an element")];
       }
       el.computed = cloneStyleMap(op.style);
-      markTouched(state, op.target);
+      markStyleDirty(state, op.target);
       return [];
     }
     case "mergeStyle": {
@@ -881,7 +1096,7 @@ function applyOne(state, op) {
         const src = doc.nodes.get(op.source);
         if (src) markTouched(state, op.source);
       }
-      markTouched(state, op.target);
+      markStyleDirty(state, op.target);
       return [];
     }
     case "foldInheritedStyles":
@@ -932,7 +1147,7 @@ function applyFold(state, op) {
     }
     if (folded) {
       into.computed = { blocks: nextBlocks };
-      markTouched(state, intoId);
+      markStyleDirty(state, intoId);
     }
   }
   for (const d3 of issues) state.diagnostics.push(d3);
@@ -1197,8 +1412,123 @@ init_cjs_shims();
 var DISPLAY = "display";
 var POSITION = "position";
 var TRANSFORM = "transform";
+var ALIGN_ITEMS = "align-items";
+var JUSTIFY_CONTENT = "justify-content";
+var JUSTIFY_ITEMS = "justify-items";
+var PLACE_ITEMS = "place-items";
+var PLACE_SELF = "place-self";
 var CONTEXT_SAFE_DISPLAYS = /* @__PURE__ */ new Set(["block", "contents", ""]);
 var STATIC_POSITIONS = /* @__PURE__ */ new Set(["static", ""]);
+var CENTERING_DISPLAYS = /* @__PURE__ */ new Set(["flex", "grid"]);
+var GRID_PARENT_DISPLAYS = /* @__PURE__ */ new Set(["grid"]);
+var STRETCHY_ITEM_ALIGN = /* @__PURE__ */ new Set(["normal", "stretch"]);
+var PARENT_ITEMS_ALIGN_PROPS = [ALIGN_ITEMS, JUSTIFY_ITEMS, PLACE_ITEMS];
+function isBaseCondition(block) {
+  const c = block.condition;
+  return c.media === "" && c.states.length === 0 && c.pseudoElement === "";
+}
+function baseValue(sm, prop) {
+  for (const block of sm.blocks.values()) {
+    if (!isBaseCondition(block)) continue;
+    const d3 = block.decls.get(prop);
+    return d3 ? String(d3.value) : null;
+  }
+  return null;
+}
+function parentIsFillingGrid(before, wrapper, norm) {
+  if (wrapper.parent == null) return false;
+  const p2 = before.nodes.get(wrapper.parent);
+  if (!p2 || p2.kind !== "element") return false;
+  const pc2 = norm.normalizeStyleMap(p2.computed);
+  let baseIsGrid = false;
+  for (const block of pc2.blocks.values()) {
+    const disp = block.decls.get(DISPLAY);
+    if (disp) {
+      if (!GRID_PARENT_DISPLAYS.has(String(disp.value))) return false;
+      if (isBaseCondition(block)) baseIsGrid = true;
+    }
+    for (const prop of PARENT_ITEMS_ALIGN_PROPS) {
+      const d3 = block.decls.get(prop);
+      if (d3 && !STRETCHY_ITEM_ALIGN.has(String(d3.value))) return false;
+    }
+  }
+  return baseIsGrid;
+}
+function wrapperHasOnlyCenteringStyle(wrapperComputed, childComputed, norm) {
+  for (const block of wrapperComputed.blocks.values()) {
+    const base = isBaseCondition(block);
+    const ck = conditionKey(block.condition);
+    for (const [prop, decl] of block.decls) {
+      const val = String(decl.value);
+      if (prop === DISPLAY) {
+        if (base && CENTERING_DISPLAYS.has(val)) continue;
+        return false;
+      }
+      if (prop === ALIGN_ITEMS) {
+        if (base && val === "center") continue;
+        return false;
+      }
+      if (prop === JUSTIFY_CONTENT) {
+        if (base && val === "center") continue;
+        return false;
+      }
+      if (prop === POSITION) {
+        if (STATIC_POSITIONS.has(val)) continue;
+        return false;
+      }
+      if (prop === TRANSFORM) {
+        if (val === "none") continue;
+        return false;
+      }
+      if (isInherited2(decl, norm)) continue;
+      if (childReproduces(childComputed, ck, prop, val)) continue;
+      return false;
+    }
+  }
+  return true;
+}
+function wrapperCentersSingleElement(before, wrapper) {
+  let elements = 0;
+  for (const cid of wrapper.children) {
+    const n = before.nodes.get(cid);
+    if (!n) continue;
+    if (n.kind === "element") {
+      elements += 1;
+      continue;
+    }
+    if (n.kind === "comment") continue;
+    if (n.kind === "text" && n.value.trim() === "") continue;
+    return false;
+  }
+  return elements === 1;
+}
+function childHasSelfAlign(childBefore, norm) {
+  if (!childBefore) return false;
+  const sm = norm.normalizeStyleMap(childBefore);
+  for (const block of sm.blocks.values()) {
+    for (const prop of SELF_ALIGN_PROPS) {
+      const d3 = block.decls.get(prop);
+      if (d3 && !NEUTRAL_ALIGN.has(String(d3.value))) return true;
+    }
+  }
+  return false;
+}
+function childGainsPlaceSelfCenter(childAfter) {
+  if (baseValue(childAfter, PLACE_SELF) === "center") return true;
+  return baseValue(childAfter, "align-self") === "center" && baseValue(childAfter, "justify-self") === "center";
+}
+function isContextCompensatedCentering(before, wrapper, wrapperComputed, childBefore, childAfter, norm) {
+  if (!childAfter) return false;
+  if (!CENTERING_DISPLAYS.has(baseValue(wrapperComputed, DISPLAY) ?? "")) return false;
+  if (baseValue(wrapperComputed, ALIGN_ITEMS) !== "center") return false;
+  if (baseValue(wrapperComputed, JUSTIFY_CONTENT) !== "center") return false;
+  const childAfterNorm = norm.normalizeStyleMap(childAfter);
+  if (!childGainsPlaceSelfCenter(childAfterNorm)) return false;
+  if (!wrapperHasOnlyCenteringStyle(wrapperComputed, childAfterNorm, norm)) return false;
+  if (!wrapperCentersSingleElement(before, wrapper)) return false;
+  if (childHasSelfAlign(childBefore, norm)) return false;
+  return parentIsFillingGrid(before, wrapper, norm);
+}
 var SELF_ALIGN_PROPS = [
   "place-self",
   "align-self",
@@ -1298,6 +1628,9 @@ function classifyFlattenOps(before, after, ops, norm) {
   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 (isContextCompensatedCentering(before, wrapper, wrapperComputed, childBefore, childAfter, norm)) {
+    return { kind: "provably-safe", wrapperId, childId };
+  }
   if (establishesChildContext(wrapperComputed)) {
     return { kind: "needs-verification", wrapperId, childId };
   }
@@ -1579,15 +1912,34 @@ function sameTokens(a, b3) {
   for (let i = 0; i < a.length; i += 1) if (a[i] !== b3[i]) return false;
   return true;
 }
+function residualStyle(computed2, covered, norm) {
+  const cov = norm.normalizeStyleMap(covered);
+  const blocks = /* @__PURE__ */ new Map();
+  for (const [key, block] of norm.normalizeStyleMap(computed2).blocks) {
+    const covBlock = cov.blocks.get(key);
+    const decls = /* @__PURE__ */ new Map();
+    for (const [prop, decl] of block.decls) {
+      const covDecl = covBlock?.decls.get(prop);
+      if (covDecl && covDecl.value === decl.value && covDecl.important === decl.important) continue;
+      decls.set(prop, decl);
+    }
+    if (decls.size > 0) blocks.set(key, { condition: block.condition, decls });
+  }
+  return { blocks };
+}
 function syncClassesFromComputed(doc, resolver, norm) {
   const sink = createSyntheticSink();
   for (const id of elementIds(doc)) {
     const el = getElement(doc, id);
-    if (!el || !el.meta.touched) continue;
+    if (!el) continue;
+    if (!el.meta.styleDirty) continue;
     if (el.classes.opaque || el.classes.hasDynamic) continue;
     const tokens = staticTokensOf(el.classes);
+    const retained = tokens.filter((t) => !resolver.selectorUsage(t).droppable);
+    const covered = retained.length > 0 ? resolver.resolve({ classes: retained }).styles : null;
+    const target = covered ? residualStyle(el.computed, covered, norm) : el.computed;
     const ctx = { normalizer: norm, sink };
-    const emitted = resolver.emit(el.computed, ctx).classes;
+    const emitted = resolver.emit(target, ctx).classes;
     if (emitted.length === 0) continue;
     const emittedSet = new Set(emitted);
     const next = [];
@@ -1610,6 +1962,350 @@ function syncClassesFromComputed(doc, resolver, norm) {
   }
 }
 
+// ../frontend-html/src/index.ts
+init_cjs_shims();
+
+// ../frontend-html/src/backend.ts
+init_cjs_shims();
+var import_magic_string = __toESM(require("magic-string"), 1);
+function staticTokensOf2(classes) {
+  const out = [];
+  for (const seg of classes.segments) {
+    if (seg.kind === "static") for (const t of seg.tokens) out.push(t.value);
+  }
+  return out;
+}
+function sameTokens2(a, b3) {
+  if (a.length !== b3.length) return false;
+  for (let i = 0; i < a.length; i += 1) if (a[i] !== b3[i]) return false;
+  return true;
+}
+function primarySource(doc) {
+  for (const sf of doc.sources.values()) {
+    if (typeof sf.text === "string" && sf.text.length > 0) return sf;
+  }
+  return null;
+}
+function collectKept(doc) {
+  const out = [];
+  const seen = /* @__PURE__ */ new Set();
+  const visit = (id) => {
+    if (seen.has(id)) return;
+    seen.add(id);
+    const n = doc.nodes.get(id);
+    if (!n) return;
+    out.push(n);
+    if (n.kind === "element" || n.kind === "fragment") for (const c of n.children) visit(c);
+  };
+  visit(doc.root);
+  return out;
+}
+function strictlyContains(a, b3) {
+  if (a.file !== b3.file) return false;
+  if (a.start <= b3.start && b3.end <= a.end) return !(a.start === b3.start && a.end === b3.end);
+  return false;
+}
+function backrefIds(doc) {
+  const out = [];
+  const max = doc.alloc.peek;
+  for (let i = 1; i < max; i += 1) {
+    const id = i;
+    if (doc.backref.get(id)) out.push(id);
+  }
+  return out;
+}
+function currentTokens(sf, valueSpan) {
+  const raw = sf.text.slice(valueSpan.start, valueSpan.end).trim();
+  const unquoted = raw.replace(/^['"]/, "").replace(/['"]$/, "");
+  return unquoted.split(/\s+/).filter((t) => t.length > 0);
+}
+function editClasses(ms, doc, sf, el) {
+  const classes = el.classes;
+  if (classes.hasDynamic || classes.opaque) return false;
+  const tokens = staticTokensOf2(classes);
+  const valueSpan = classes.valueSpan;
+  if (valueSpan && valueSpan.file === sf.id) {
+    if (sameTokens2(currentTokens(sf, valueSpan), tokens)) return false;
+    const current = sf.text.slice(valueSpan.start, valueSpan.end).trim();
+    const quote = current.startsWith("'") ? "'" : '"';
+    ms.overwrite(valueSpan.start, valueSpan.end, `${quote}${tokens.join(" ")}${quote}`);
+    return true;
+  }
+  if (tokens.length === 0) return false;
+  const openTag = doc.backref.get(el.id)?.openTagSpan;
+  if (!openTag || openTag.file !== sf.id) return false;
+  ms.appendLeft(openTag.start + 1 + el.tag.length, ` class="${tokens.join(" ")}"`);
+  return true;
+}
+function surgicalPrint(doc) {
+  const sf = primarySource(doc);
+  if (!sf) return null;
+  const ms = new import_magic_string.default(sf.text);
+  const kept = collectKept(doc);
+  const keptSpans = [];
+  for (const n of kept) if (n.span && n.span.file === sf.id) keptSpans.push(n.span);
+  const removed = [];
+  for (const id of backrefIds(doc)) {
+    if (doc.nodes.has(id)) continue;
+    const back = doc.backref.get(id);
+    if (!back || back.span.file !== sf.id) continue;
+    const unwrapped = keptSpans.some((k3) => strictlyContains(back.span, k3));
+    removed.push({ backref: back, unwrapped });
+  }
+  const fullRemovals = removed.filter((r2) => !r2.unwrapped).map((r2) => r2.backref.span);
+  for (const r2 of removed) {
+    const s = r2.backref.span;
+    if (fullRemovals.some((f) => f !== s && strictlyContains(f, s))) continue;
+    if (r2.unwrapped) {
+      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);
+      if (close && close.file === sf.id && close.end > close.start) ms.remove(close.start, close.end);
+    } else {
+      ms.remove(s.start, s.end);
+    }
+  }
+  for (const n of kept) if (n.kind === "element") editClasses(ms, doc, sf, n);
+  return ms.toString();
+}
+function doPrint(doc) {
+  return surgicalPrint(doc) ?? "";
+}
+
+// ../frontend-html/src/parse.ts
+init_cjs_shims();
+var import_node_module = require("module");
+
+// ../frontend-html/src/walk.ts
+init_cjs_shims();
+var HTML_LANGS = ["html"];
+var FILE_ID = 1;
+function looksLikeHtml(id, code) {
+  if (/\.html?$/i.test(id)) return true;
+  const head = code.slice(0, 256).trimStart().toLowerCase();
+  return head.startsWith("<!doctype html") || head.startsWith("<html") || head.startsWith("<");
+}
+var OPAQUE_SUBTREE_TAGS = /* @__PURE__ */ new Set([
+  "script",
+  "style",
+  "template",
+  "svg",
+  "pre",
+  "textarea"
+]);
+function isOpaqueSubtreeTag(tag) {
+  return OPAQUE_SUBTREE_TAGS.has(tag);
+}
+function elementIsOpaque(attrs) {
+  for (const a of attrs) {
+    const n = a.name.toLowerCase();
+    if (n === "id" || n === "contenteditable") return true;
+    if (n.startsWith("on")) return true;
+  }
+  return false;
+}
+function hasEventHandler(attrs) {
+  for (const a of attrs) if (/^on/i.test(a.name)) return true;
+  return false;
+}
+function span(start, end) {
+  return { file: FILE_ID, start, end };
+}
+function attrsLocOf(loc) {
+  if (!loc) return void 0;
+  return loc.startTag?.attrs ?? loc.attrs;
+}
+function classValueSpan(loc, source) {
+  const attrsLoc = attrsLocOf(loc);
+  const cl = attrsLoc?.["class"];
+  if (!cl) return null;
+  const text = source.slice(cl.startOffset, cl.endOffset);
+  const eq = text.indexOf("=");
+  if (eq === -1) return null;
+  let i = eq + 1;
+  while (i < text.length && /\s/.test(text[i])) i += 1;
+  if (i >= text.length) return null;
+  return span(cl.startOffset + i, cl.endOffset);
+}
+
+// ../frontend-html/src/parse.ts
+var cachedParse5 = null;
+function loadParse5() {
+  if (cachedParse5) return cachedParse5;
+  const req = (0, import_node_module.createRequire)(importMetaUrl);
+  cachedParse5 = req("parse5");
+  return cachedParse5;
+}
+function doParse(code, ctx) {
+  const diagnostics = [];
+  const doc = createDocument("html");
+  const backref = doc.backref;
+  const parse5 = loadParse5();
+  const document2 = parse5.parse(code, { sourceCodeLocationInfo: true });
+  const eol = code.includes("\r\n") ? "\r\n" : "\n";
+  const sourceFile = {
+    id: FILE_ID,
+    path: ctx.id,
+    text: code,
+    frontend: "html",
+    eol,
+    indentUnit: "  ",
+    native: document2
+  };
+  doc.sources.set(FILE_ID, sourceFile);
+  const resolveComputed = (tokens, tag, nodeId) => {
+    if (tokens.length === 0) return emptyStyleMap();
+    const res = ctx.resolver.resolve({ classes: tokens, element: { tagName: tag, namespace: "html" } });
+    for (const w2 of res.warnings) {
+      diagnostics.push({
+        code: "DF_STYLE_CONFLICT_UNRESOLVED",
+        severity: w2.severity,
+        message: w2.message,
+        nodeId
+      });
+    }
+    return ctx.normalizer.normalizeStyleMap(res.styles);
+  };
+  const splitTokens = (raw) => raw.split(/\s+/).filter((t) => t.length > 0);
+  const appendChild = (node, parentId, out) => {
+    const name = node.nodeName;
+    if (name === "#text") {
+      const value = node.value ?? "";
+      const id = doc.alloc.next();
+      const loc = node.sourceCodeLocation ?? null;
+      doc.nodes.set(
+        id,
+        createText(id, value, {
+          parent: parentId,
+          span: loc ? span(loc.startOffset, loc.endOffset) : null,
+          collapsible: /^\s*$/.test(value)
+        })
+      );
+      out.push(id);
+      return;
+    }
+    if (name === "#comment") {
+      const id = doc.alloc.next();
+      const loc = node.sourceCodeLocation ?? null;
+      doc.nodes.set(
+        id,
+        createComment(id, node.data ?? "", {
+          parent: parentId,
+          span: loc ? span(loc.startOffset, loc.endOffset) : null
+        })
+      );
+      out.push(id);
+      return;
+    }
+    if (name === "#documentType") return;
+    if (name.startsWith("#")) {
+      for (const c of node.childNodes ?? []) appendChild(c, parentId, out);
+      return;
+    }
+    out.push(buildElement(node, parentId));
+  };
+  const buildElement = (node, parentId) => {
+    const id = doc.alloc.next();
+    const tag = (node.tagName ?? node.nodeName).toLowerCase();
+    const loc = node.sourceCodeLocation ?? null;
+    const attrsArr = node.attrs ?? [];
+    const opaqueSubtree = isOpaqueSubtreeTag(tag);
+    const synthetic = loc == null;
+    const opaque2 = opaqueSubtree || synthetic || elementIsOpaque(attrsArr);
+    const meta = defaultMeta();
+    meta.hasEventHandlers = hasEventHandler(attrsArr);
+    meta.safetyFloor = opaque2 ? 0 : 3;
+    let classes = emptyClassList();
+    let classTokens = [];
+    const entries = /* @__PURE__ */ new Map();
+    const order = [];
+    for (const a of attrsArr) {
+      if (a.name.toLowerCase() === "class") {
+        classTokens = splitTokens(a.value);
+        const valueSpan = classValueSpan(loc, code);
+        const clAttr = attrsLocOf(loc)?.["class"];
+        const seg = {
+          kind: "static",
+          span: valueSpan ?? void 0,
+          tokens: classTokens.map((value) => ({ value }))
+        };
+        classes = {
+          form: "string-literal",
+          segments: [seg],
+          valueSpan,
+          attrSpan: clAttr ? span(clAttr.startOffset, clAttr.endOffset) : void 0,
+          hasDynamic: false,
+          opaque: false,
+          rewritable: valueSpan != null
+        };
+        continue;
+      }
+      const v2 = a.value;
+      entries.set(a.name, { kind: "static", value: v2 === "" ? true : v2 });
+      order.push(a.name);
+    }
+    const attrs = { entries, spreads: [], order };
+    const computed2 = resolveComputed(classTokens, tag, id);
+    const children = [];
+    if (!opaqueSubtree) {
+      for (const c of node.childNodes ?? []) appendChild(c, id, children);
+    }
+    const el = createElement(id, {
+      tag,
+      namespace: "html",
+      isComponent: false,
+      selfClosing: loc ? loc.endTag == null : false,
+      classes,
+      computed: computed2,
+      attrs,
+      children,
+      parent: parentId,
+      span: loc ? span(loc.startOffset, loc.endOffset) : null,
+      meta
+    });
+    doc.nodes.set(id, el);
+    if (loc) {
+      backref.set(id, {
+        nodeId: id,
+        span: span(loc.startOffset, loc.endOffset),
+        openTagSpan: loc.startTag ? span(loc.startTag.startOffset, loc.startTag.endOffset) : null,
+        closeTagSpan: loc.endTag ? span(loc.endTag.startOffset, loc.endTag.endOffset) : null,
+        innerSpan: null,
+        selfClosing: loc.endTag == null
+      });
+    }
+    return id;
+  };
+  const rootFrag = doc.nodes.get(doc.root);
+  appendChild(document2, doc.root, rootFrag.children);
+  return { doc, diagnostics };
+}
+
+// ../frontend-html/src/index.ts
+var htmlFrontend = {
+  name: "html",
+  langs: HTML_LANGS,
+  canParse(id, code) {
+    return looksLikeHtml(id, code);
+  },
+  parse(code, ctx) {
+    return doParse(code, ctx);
+  }
+};
+function createHtmlFrontend() {
+  return htmlFrontend;
+}
+var htmlBackend = {
+  name: "html",
+  langs: HTML_LANGS,
+  print(doc, _plan, _ctx) {
+    return { code: doPrint(doc), map: null, edits: [], diagnostics: [] };
+  }
+};
+function createHtmlBackend() {
+  return htmlBackend;
+}
+
 // ../frontend-jsx/src/index.ts
 init_cjs_shims();
 
@@ -1621,7 +2317,7 @@ 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"];
-var FILE_ID = 1;
+var FILE_ID2 = 1;
 function jsxName(node) {
   switch (node.type) {
     case "JSXIdentifier":
@@ -1746,7 +2442,7 @@ function looksLikeJsx(id, code) {
 // ../frontend-jsx/src/frontend-parse.ts
 init_cjs_shims();
 var import_parser = require("@babel/parser");
-function doParse(code, ctx) {
+function doParse2(code, ctx) {
   const diagnostics = [];
   const doc = createDocument("jsx");
   const backref = doc.backref;
@@ -1756,7 +2452,7 @@ function doParse(code, ctx) {
   });
   const eol = code.includes("\r\n") ? "\r\n" : "\n";
   const sourceFile = {
-    id: FILE_ID,
+    id: FILE_ID2,
     path: ctx.id,
     text: code,
     frontend: "jsx",
@@ -1764,23 +2460,23 @@ function doParse(code, ctx) {
     indentUnit: "  ",
     native: ast
   };
-  doc.sources.set(FILE_ID, sourceFile);
+  doc.sources.set(FILE_ID2, sourceFile);
   const spanOf = (node) => {
     if (node.start == null || node.end == null) return null;
-    const span = {
-      file: FILE_ID,
+    const span2 = {
+      file: FILE_ID2,
       start: node.start,
       end: node.end,
       startLoc: node.loc ? { line: node.loc.start.line, column: node.loc.start.column } : void 0,
       endLoc: node.loc ? { line: node.loc.end.line, column: node.loc.end.column } : void 0
     };
-    return span;
+    return span2;
   };
   const sliceOf = (node) => node.start == null || node.end == null ? "" : code.slice(node.start, node.end);
   const internExpr = (node, spread) => {
     const payload = { text: sliceOf(node), spread };
     return doc.exprs.intern({
-      span: spanOf(node) ?? { file: FILE_ID, start: 0, end: 0 },
+      span: spanOf(node) ?? { file: FILE_ID2, start: 0, end: 0 },
       kind: exprKind(node),
       payload
     });
@@ -1826,7 +2522,7 @@ function doParse(code, ctx) {
     }
     return emptyClassList();
   };
-  const staticTokensOf3 = (classes) => {
+  const staticTokensOf4 = (classes) => {
     const out = [];
     for (const seg of classes.segments) {
       if (seg.kind === "static") for (const t of seg.tokens) out.push(t.value);
@@ -1904,7 +2600,7 @@ function doParse(code, ctx) {
     doc.nodes.set(id, createFragment(id, { children, parent: parentId, span: spanOf(node) }));
     backref.set(id, {
       nodeId: id,
-      span: spanOf(node) ?? { file: FILE_ID, start: 0, end: 0 },
+      span: spanOf(node) ?? { file: FILE_ID2, start: 0, end: 0 },
       openTagSpan: spanOf(node.openingFragment),
       closeTagSpan: spanOf(node.closingFragment),
       innerSpan: null,
@@ -1953,7 +2649,7 @@ function doParse(code, ctx) {
     }
     let computed2 = emptyStyleMap();
     if (!classes.hasDynamic) {
-      const tokens = staticTokensOf3(classes);
+      const tokens = staticTokensOf4(classes);
       if (tokens.length > 0) {
         const res = ctx.resolver.resolve({
           classes: tokens,
@@ -1986,13 +2682,13 @@ function doParse(code, ctx) {
     });
     doc.nodes.set(id, el);
     const inner = children.length > 0 ? spanOf(node.children[0]) && spanOf(node.children.at(-1)) ? {
-      file: FILE_ID,
+      file: FILE_ID2,
       start: spanOf(node.children[0]).start,
       end: spanOf(node.children.at(-1)).end
     } : null : null;
     backref.set(id, {
       nodeId: id,
-      span: spanOf(node) ?? { file: FILE_ID, start: 0, end: 0 },
+      span: spanOf(node) ?? { file: FILE_ID2, start: 0, end: 0 },
       openTagSpan: spanOf(opening),
       closeTagSpan: node.closingElement ? spanOf(node.closingElement) : null,
       innerSpan: inner,
@@ -2002,13 +2698,13 @@ function doParse(code, ctx) {
   };
   const roots = [];
   traverse(ast, {
-    JSXElement(path7) {
-      roots.push(path7.node);
-      path7.skip();
+    JSXElement(path10) {
+      roots.push(path10.node);
+      path10.skip();
     },
-    JSXFragment(path7) {
-      roots.push(path7.node);
-      path7.skip();
+    JSXFragment(path10) {
+      roots.push(path10.node);
+      path10.skip();
     }
   });
   const rootFrag = doc.nodes.get(doc.root);
@@ -2027,7 +2723,7 @@ var jsxFrontend = {
     return looksLikeJsx(id, code);
   },
   parse(code, ctx) {
-    return doParse(code, ctx);
+    return doParse2(code, ctx);
   }
 };
 function createJsxFrontend() {
@@ -2036,7 +2732,7 @@ function createJsxFrontend() {
 
 // ../frontend-jsx/src/backend.ts
 init_cjs_shims();
-var import_magic_string = __toESM(require("magic-string"), 1);
+var import_magic_string2 = __toESM(require("magic-string"), 1);
 var JSX_LANGS2 = ["jsx", "tsx"];
 function exprText(doc, ref) {
   const rec = doc.exprs.get(ref);
@@ -2050,20 +2746,20 @@ function exprText(doc, ref) {
   }
   return { text: "", spread: false };
 }
-function staticTokensOf2(classes) {
+function staticTokensOf3(classes) {
   const out = [];
   for (const seg of classes.segments) {
     if (seg.kind === "static") for (const t of seg.tokens) out.push(t.value);
   }
   return out;
 }
-function primarySource(doc) {
+function primarySource2(doc) {
   for (const sf of doc.sources.values()) {
     if (typeof sf.text === "string" && sf.text.length > 0) return sf;
   }
   return null;
 }
-function collectKept(doc) {
+function collectKept2(doc) {
   const out = [];
   const seen = /* @__PURE__ */ new Set();
   const visit = (id) => {
@@ -2077,15 +2773,15 @@ function collectKept(doc) {
   visit(doc.root);
   return out;
 }
-function strictlyContains(a, b3) {
+function strictlyContains2(a, b3) {
   if (a.file !== b3.file) return false;
   if (a.start <= b3.start && b3.end <= a.end) return !(a.start === b3.start && a.end === b3.end);
   return false;
 }
-function editClasses(ms, doc, sf, el) {
+function editClasses2(ms, doc, sf, el) {
   const classes = el.classes;
   if (classes.hasDynamic || classes.opaque) return false;
-  const tokens = staticTokensOf2(classes);
+  const tokens = staticTokensOf3(classes);
   const valueSpan = classes.valueSpan;
   if (valueSpan && valueSpan.file === sf.id) {
     const current = sf.text.slice(valueSpan.start, valueSpan.end);
@@ -2149,10 +2845,10 @@ function transferKeyOnUnwrap(ms, doc, sf, region, kept) {
   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);
+    if (strictlyContains2(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))
+    (n) => !inside.some((o2) => o2 !== n && o2.span && n.span && strictlyContains2(o2.span, n.span))
   );
   if (maximal.length !== 1) return;
   const child = maximal[0];
@@ -2161,25 +2857,25 @@ function transferKeyOnUnwrap(ms, doc, sf, region, kept) {
   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);
+function surgicalPrint2(doc) {
+  const sf = primarySource2(doc);
   if (!sf) return null;
-  const ms = new import_magic_string.default(sf.text);
-  const kept = collectKept(doc);
+  const ms = new import_magic_string2.default(sf.text);
+  const kept = collectKept2(doc);
   const keptSpans = [];
   for (const n of kept) if (n.span && n.span.file === sf.id) keptSpans.push(n.span);
   const removed = [];
-  for (const id of backrefIds(doc)) {
+  for (const id of backrefIds2(doc)) {
     if (doc.nodes.has(id)) continue;
     const back = doc.backref.get(id);
     if (!back || back.span.file !== sf.id) continue;
-    const unwrapped = keptSpans.some((k3) => strictlyContains(back.span, k3));
+    const unwrapped = keptSpans.some((k3) => strictlyContains2(back.span, k3));
     removed.push({ backref: back, unwrapped });
   }
   const fullRemovals = removed.filter((r2) => !r2.unwrapped).map((r2) => r2.backref.span);
   for (const r2 of removed) {
-    const span = r2.backref.span;
-    const coveredByFull = fullRemovals.some((f) => f !== span && strictlyContains(f, span));
+    const span2 = r2.backref.span;
+    const coveredByFull = fullRemovals.some((f) => f !== span2 && strictlyContains2(f, span2));
     if (coveredByFull) continue;
     if (r2.unwrapped) {
       transferKeyOnUnwrap(ms, doc, sf, r2.backref, kept);
@@ -2190,15 +2886,15 @@ function surgicalPrint(doc) {
         ms.remove(close.start, close.end);
       }
     } else {
-      ms.remove(span.start, span.end);
+      ms.remove(span2.start, span2.end);
     }
   }
   for (const n of kept) {
-    if (n.kind === "element") editClasses(ms, doc, sf, n);
+    if (n.kind === "element") editClasses2(ms, doc, sf, n);
   }
   return ms.toString();
 }
-function backrefIds(doc) {
+function backrefIds2(doc) {
   const out = [];
   const max = doc.alloc.peek;
   for (let i = 1; i < max; i += 1) {
@@ -2213,7 +2909,7 @@ function classText(doc, classes) {
   if (dynamic && dynamic.kind === "dynamic") {
     return `className={${exprText(doc, dynamic.expr).text}}`;
   }
-  const tokens = staticTokensOf2(classes);
+  const tokens = staticTokensOf3(classes);
   return `className="${tokens.join(" ")}"`;
 }
 function attrText(doc, name, value) {
@@ -2266,15 +2962,15 @@ function rePrint(doc) {
   if (!root || root.kind !== "fragment") return printNode(doc, doc.root);
   return root.children.map((c) => printNode(doc, c)).join("");
 }
-function doPrint(doc) {
-  const surgical = surgicalPrint(doc);
+function doPrint2(doc) {
+  const surgical = surgicalPrint2(doc);
   return surgical ?? rePrint(doc);
 }
 var jsxBackend = {
   name: "babel-jsx",
   langs: JSX_LANGS2,
   print(doc, _plan, _ctx) {
-    const code = doPrint(doc);
+    const code = doPrint2(doc);
     return { code, map: null, edits: [], diagnostics: [] };
   }
 };
@@ -2994,19 +3690,28 @@ var flexCenterWrapper = definePattern({
     flattenInto: "child",
     childGains: { placeSelf: "center" }
   },
-  // 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.
+  // Collapsing a flex-centering wrapper to `place-self:center` on the child is render-identical ONLY
+  // when the child's NEW parent is a statically-known GRID that lets the wrapper fill its area (there
+  // `place-self`'s align-self AND justify-self both take effect). Under that ONE context the flatten is
+  // classified `provably-safe` and commits; under a flex/block/unknown parent — or when the wrapper
+  // drops any own style — it stays `needs-verification` and the conservative production gate PRESERVES
+  // it. Op-level correctness (purity, id-preserving unwrap, opacity-barrier safety) is additionally
+  // asserted by the invariant suite over every pattern.
   test: {
+    cases: [
+      {
+        name: "grid parent \u2192 flattened (child gains place-self-center)",
+        before: '<div className="grid"><div className="flex items-center justify-center"><span className="bg-red-200">x</span></div></div>',
+        after: '<div className="grid"><span className="bg-red-200 place-self-center">x</span></div>'
+      }
+    ],
     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.
+      // Non-grid (flex) parent (document root): `justify-self` is ignored in flex → not provably safe.
       '<div className="flex justify-center items-center"><div className="bg-red-200">Hello</div></div>',
+      // Grid parent, but the wrapper drops padding when removed → not layout-neutral (rule 3).
+      '<div className="grid"><div className="p-4 flex items-center justify-center"><span className="bg-red-200">x</span></div></div>',
+      // Grid parent forcing place-items-center: the wrapper would not fill its area → fill guard skips.
+      '<div className="grid place-items-center"><div className="flex items-center justify-center"><span className="bg-red-200">x</span></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>'
     ]
@@ -4226,11 +4931,11 @@ var paddingShorthand = definePattern({
 
 // ../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_ITEMS2 = "align-items";
+var JUSTIFY_ITEMS2 = "justify-items";
+var PLACE_ITEMS2 = "place-items";
 var ALIGN_CONTENT = "align-content";
-var JUSTIFY_CONTENT = "justify-content";
+var JUSTIFY_CONTENT2 = "justify-content";
 var PLACE_CONTENT = "place-content";
 var BASE_KEY8 = conditionKey(BASE_CONDITION);
 function samePair(a, b3) {
@@ -4270,21 +4975,21 @@ var placeShorthand = definePattern({
     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 alignItems = base.decls.get(ALIGN_ITEMS2);
+      const justifyItems = base.decls.get(JUSTIFY_ITEMS2);
       const alignContent = base.decls.get(ALIGN_CONTENT);
-      const justifyContent = base.decls.get(JUSTIFY_CONTENT);
+      const justifyContent = base.decls.get(JUSTIFY_CONTENT2);
       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));
+        next.delete(ALIGN_ITEMS2);
+        next.delete(JUSTIFY_ITEMS2);
+        next.set(PLACE_ITEMS2, placeDecl(PLACE_ITEMS2, alignItems));
         collapsed = true;
       }
       if (samePair(alignContent, justifyContent)) {
         next.delete(ALIGN_CONTENT);
-        next.delete(JUSTIFY_CONTENT);
+        next.delete(JUSTIFY_CONTENT2);
         next.set(PLACE_CONTENT, placeDecl(PLACE_CONTENT, alignContent));
         collapsed = true;
       }
@@ -4621,19 +5326,19 @@ init_cjs_shims();
 
 // ../resolver-css/src/engine.ts
 init_cjs_shims();
-var import_node_module = require("module");
-var path2 = __toESM(require("path"), 1);
+var import_node_module2 = require("module");
+var path3 = __toESM(require("path"), 1);
 function moduleBase() {
   return typeof __filename === "string" ? __filename : importMetaUrl;
 }
 function loadPostcssEngine(projectRoot) {
   const bases = [];
-  if (projectRoot) bases.push(path2.join(projectRoot, "__domflax__.js"));
-  bases.push(path2.join(process.cwd(), "__domflax__.js"));
+  if (projectRoot) bases.push(path3.join(projectRoot, "__domflax__.js"));
+  bases.push(path3.join(process.cwd(), "__domflax__.js"));
   bases.push(moduleBase());
   for (const base of bases) {
     try {
-      const req = (0, import_node_module.createRequire)(base);
+      const req = (0, import_node_module2.createRequire)(base);
       req.resolve("postcss");
       req.resolve("postcss-selector-parser");
       const postcss = req("postcss");
@@ -4684,15 +5389,15 @@ function collectDecls(rule) {
 
 // ../resolver-css/src/misc-helpers.ts
 init_cjs_shims();
-var import_node_fs = require("fs");
+var import_node_fs2 = require("fs");
 function isPlainClassToken(token) {
   return token.length > 0 && !/[\s.#>+~:[\]()]/.test(token);
 }
-function readCssPath(path7) {
+function readCssPath(path10) {
   try {
-    return { id: path7, css: (0, import_node_fs.readFileSync)(path7, "utf8") };
+    return { id: path10, css: (0, import_node_fs2.readFileSync)(path10, "utf8") };
   } catch (cause) {
-    throw new Error(`resolver-css: cannot read CSS file "${path7}"`, { cause });
+    throw new Error(`resolver-css: cannot read CSS file "${path10}"`, { cause });
   }
 }
 function deriveFingerprint(provider, files) {
@@ -5070,19 +5775,19 @@ function synthesizeResidual(remaining, ctx) {
 
 // ../resolver-tailwind/src/tailwind/engine.ts
 init_cjs_shims();
-var import_node_module2 = require("module");
-var path3 = __toESM(require("path"), 1);
+var import_node_module3 = require("module");
+var path4 = __toESM(require("path"), 1);
 function moduleBase2() {
   return typeof __filename === "string" ? __filename : importMetaUrl;
 }
 function projectRequire(projectRoot) {
   const bases = [];
-  if (projectRoot) bases.push(path3.join(projectRoot, "__domflax__.js"));
-  bases.push(path3.join(process.cwd(), "__domflax__.js"));
+  if (projectRoot) bases.push(path4.join(projectRoot, "__domflax__.js"));
+  bases.push(path4.join(process.cwd(), "__domflax__.js"));
   bases.push(moduleBase2());
   for (const base of bases) {
     try {
-      const candidate = (0, import_node_module2.createRequire)(base);
+      const candidate = (0, import_node_module3.createRequire)(base);
       candidate.resolve("tailwindcss/package.json");
       return candidate;
     } catch {
@@ -5501,6 +6206,74 @@ function createTailwindResolver(config) {
   return new TailwindResolver(config);
 }
 
+// ../cli/src/transform.ts
+var path6 = __toESM(require("path"), 1);
+
+// ../cli/src/html-css.ts
+init_cjs_shims();
+var import_node_crypto = require("crypto");
+var import_node_fs3 = require("fs");
+var path5 = __toESM(require("path"), 1);
+function isRemoteHref(href) {
+  const h2 = href.trim();
+  return h2.startsWith("//") || /^[a-z][a-z0-9+.-]*:/i.test(h2);
+}
+function attrValue(tag, name) {
+  const re = new RegExp(`\\b${name}\\s*=\\s*(?:"([^"]*)"|'([^']*)'|([^\\s"'>]+))`, "i");
+  const m2 = re.exec(tag);
+  if (!m2) return null;
+  return (m2[1] ?? m2[2] ?? m2[3] ?? "").trim();
+}
+function extractLinkHrefs(html) {
+  const out = [];
+  const linkRe = /<link\b[^>]*>/gi;
+  let m2;
+  while ((m2 = linkRe.exec(html)) !== null) {
+    const tag = m2[0];
+    const rel = attrValue(tag, "rel");
+    if (rel === null || !/(?:^|\s)stylesheet(?:\s|$)/i.test(rel)) continue;
+    const href = attrValue(tag, "href");
+    if (href) out.push(href);
+  }
+  return out;
+}
+function extractInlineStyles(html) {
+  const out = [];
+  const styleRe = /<style\b([^>]*)>([\s\S]*?)<\/style>/gi;
+  let m2;
+  while ((m2 = styleRe.exec(html)) !== null) {
+    const type = attrValue(`<style ${m2[1] ?? ""}>`, "type")?.toLowerCase();
+    if (type && type !== "text/css" && type !== "css") continue;
+    const css = m2[2] ?? "";
+    if (css.trim().length > 0) out.push(css);
+  }
+  return out;
+}
+function extractHtmlStylesheets(htmlCode, htmlAbsPath) {
+  const dir = path5.dirname(path5.resolve(htmlAbsPath));
+  const files = [];
+  const seen = /* @__PURE__ */ new Set();
+  for (const rawHref of extractLinkHrefs(htmlCode)) {
+    const href = (rawHref.split(/[?#]/, 1)[0] ?? "").trim();
+    if (!href || isRemoteHref(href)) continue;
+    const abs = path5.resolve(dir, href);
+    if (seen.has(abs)) continue;
+    seen.add(abs);
+    if ((0, import_node_fs3.existsSync)(abs)) files.push(abs);
+  }
+  return { files, inline: extractInlineStyles(htmlCode) };
+}
+function cssSetKey(sortedResolvedPaths, inline) {
+  const h2 = (0, import_node_crypto.createHash)("sha1");
+  h2.update(sortedResolvedPaths.join("\n"));
+  h2.update("\0inline\0");
+  for (const block of inline) {
+    h2.update(block);
+    h2.update("\0");
+  }
+  return h2.digest("hex");
+}
+
 // ../cli/src/transform.ts
 function buildResolver(provider, css, projectRoot) {
   if (provider === "custom") {
@@ -5537,6 +6310,11 @@ function jsxKindOf(id) {
   if (lower.endsWith(".jsx")) return "jsx";
   return null;
 }
+function htmlKindOf(id) {
+  const lower = (id.split("?", 1)[0] ?? id).toLowerCase();
+  if (lower.endsWith(".html") || lower.endsWith(".htm")) return "html";
+  return null;
+}
 function countClassTokens(code) {
   let total = 0;
   const re = /\b(?:className|class)\s*=\s*"([^"]*)"/g;
@@ -5569,9 +6347,25 @@ function passthroughResult(code) {
 }
 function createTransform(options) {
   const projectRoot = options.projectRoot ?? process.cwd();
-  const resolver = buildResolver(options.provider, options.css, projectRoot);
+  const globalResolver = buildResolver(options.provider, options.css, projectRoot);
   const patterns = selectPatterns(options.passes);
-  function prepare(code, id, kind, gate) {
+  const resolverCache = /* @__PURE__ */ new Map();
+  function resolverFor(code, id) {
+    if (options.provider !== "custom" || htmlKindOf(id) === null) return globalResolver;
+    const { files: localFiles, inline } = extractHtmlStylesheets(code, id);
+    if (localFiles.length === 0 && inline.length === 0) return globalResolver;
+    const globalPaths = options.css.map((p2) => path6.resolve(p2));
+    const sortedPaths = [.../* @__PURE__ */ new Set([...globalPaths, ...localFiles])].sort();
+    const key = cssSetKey(sortedPaths, inline);
+    let resolver = resolverCache.get(key);
+    if (!resolver) {
+      const inlineFiles = inline.map((css, i) => ({ id: `${id}#inline-${i}`, css }));
+      resolver = createCssResolver(inlineFiles, { files: sortedPaths, projectRoot });
+      resolverCache.set(key, resolver);
+    }
+    return resolver;
+  }
+  function prepare(code, id, kind, gate, resolver) {
     const parsed = createJsxFrontend().parse(code, {
       id,
       kind,
@@ -5596,9 +6390,32 @@ function createTransform(options) {
     };
     return { doc, ctx, passes: buildPasses(patterns), nodesIn };
   }
-  function finish(code, optimized, id, nodesIn) {
+  function prepareHtml(code, id, gate, resolver) {
+    const parsed = createHtmlFrontend().parse(code, {
+      id,
+      kind: "html",
+      resolver,
+      normalizer,
+      config: {},
+      onDiagnostic: () => {
+      }
+    });
+    const doc = parsed.doc;
+    const nodesIn = doc.nodes.size;
+    const ctx = {
+      doc,
+      safetyCeiling: options.safety,
+      normalizer,
+      selectors: buildSelectorIndex(doc, resolver),
+      resolver,
+      gate
+    };
+    return { doc, ctx, passes: buildPasses(patterns), nodesIn };
+  }
+  function finish(code, optimized, id, nodesIn, resolver, backend = "jsx") {
     syncClassesFromComputed(optimized, resolver, normalizer);
-    const printed = createJsxBackend().print(
+    const print = backend === "html" ? createHtmlBackend().print : createJsxBackend().print;
+    const printed = print(
       optimized,
       { moduleId: id, ops: [], provenance: /* @__PURE__ */ new Map() },
       { normalizer, resolver, sink: createSyntheticSink(), eol: "\n", onDiagnostic: () => {
@@ -5626,24 +6443,30 @@ function createTransform(options) {
     };
   }
   return {
-    resolver,
+    resolver: globalResolver,
     transformFile(code, id) {
       const kind = jsxKindOf(id);
-      if (kind === null) return passthroughResult(code);
-      const { doc, ctx, passes, nodesIn } = prepare(code, id, kind, "provably-safe");
-      const { doc: optimized } = runPasses(doc, passes, ctx);
-      return finish(code, optimized, id, nodesIn);
+      if (kind !== null) {
+        const resolver = resolverFor(code, id);
+        const { doc, ctx, passes, nodesIn } = prepare(code, id, kind, "provably-safe", resolver);
+        const { doc: optimized } = runPasses(doc, passes, ctx);
+        return finish(code, optimized, id, nodesIn, resolver);
+      }
+      if (htmlKindOf(id) !== null) {
+        const resolver = resolverFor(code, id);
+        const { doc, ctx, passes, nodesIn } = prepareHtml(code, id, "provably-safe", resolver);
+        const { doc: optimized } = runPasses(doc, passes, ctx);
+        return finish(code, optimized, id, nodesIn, resolver, "html");
+      }
+      return passthroughResult(code);
     }
   };
 }
-function builtinPatternNames() {
-  return builtinPatterns.map((p2) => p2.name);
-}
 
 // ../cli/src/walk.ts
 init_cjs_shims();
 var fs = __toESM(require("fs"), 1);
-var path4 = __toESM(require("path"), 1);
+var path7 = __toESM(require("path"), 1);
 var SUPPORTED_EXTS = [".jsx", ".tsx", ".html", ".htm"];
 var SKIP_DIRS = /* @__PURE__ */ new Set(["node_modules", ".git", "domflax-out"]);
 function isSupported(file) {
@@ -5661,12 +6484,12 @@ function walkDir(dir, out) {
     return;
   }
   for (const entry of entries) {
-    const full = path4.join(dir, entry.name);
+    const full = path7.join(dir, entry.name);
     if (entry.isDirectory()) {
       if (SKIP_DIRS.has(entry.name)) continue;
       walkDir(full, out);
-    } else if (entry.isFile() && isSupported(entry.name)) {
-      out.push(full);
+    } else if (entry.isFile()) {
+      if (isSupported(entry.name)) out.push(full);
     }
   }
 }
@@ -5679,7 +6502,7 @@ function discoverInputs(paths) {
   const warnings = [];
   const seen = /* @__PURE__ */ new Set();
   const push = (f) => {
-    const abs = path4.resolve(f);
+    const abs = path7.resolve(f);
     if (!seen.has(abs)) {
       seen.add(abs);
       files.push(abs);
@@ -5688,7 +6511,7 @@ function discoverInputs(paths) {
   let inputRoot = process.cwd();
   if (paths.length === 1) {
     try {
-      if (fs.statSync(paths[0]).isDirectory()) inputRoot = path4.resolve(paths[0]);
+      if (fs.statSync(paths[0]).isDirectory()) inputRoot = path7.resolve(paths[0]);
     } catch {
     }
   }
@@ -5700,11 +6523,12 @@ function discoverInputs(paths) {
       stat = null;
     }
     if (stat?.isDirectory()) {
-      walkDir(path4.resolve(p2), files);
+      walkDir(path7.resolve(p2), files);
       continue;
     }
     if (stat?.isFile()) {
-      push(p2);
+      if (isSupported(p2)) push(p2);
+      else warnings.push(`unsupported file type, skipped: ${p2}`);
       continue;
     }
     if (hasGlobMagic(p2)) {
@@ -5713,9 +6537,10 @@ function discoverInputs(paths) {
         warnings.push(`glob not supported on this Node version, skipped: ${p2}`);
         continue;
       }
-      const matches = glob(p2).filter(isSupported);
-      if (matches.length === 0) warnings.push(`no files matched: ${p2}`);
-      for (const m2 of matches) push(m2);
+      const matched = glob(p2);
+      const supported = matched.filter(isSupported);
+      if (supported.length === 0) warnings.push(`no .jsx/.tsx/.html files matched: ${p2}`);
+      for (const m2 of supported) push(m2);
       continue;
     }
     warnings.push(`no such file or directory: ${p2}`);
@@ -5723,7 +6548,7 @@ function discoverInputs(paths) {
   const deduped = [];
   const finalSeen = /* @__PURE__ */ new Set();
   for (const f of files) {
-    const abs = path4.resolve(f);
+    const abs = path7.resolve(f);
     if (!finalSeen.has(abs)) {
       finalSeen.add(abs);
       deduped.push(abs);
@@ -6316,7 +7141,7 @@ 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 path8 = __toESM(require("path"), 1);
 var SKIP_DIRS2 = /* @__PURE__ */ new Set([
   "node_modules",
   "dist",
@@ -6329,15 +7154,17 @@ var SKIP_DIRS2 = /* @__PURE__ */ new Set([
 ]);
 var COMMON_INPUT_DIRS = ["src", "app", "components", "pages", "lib", "ui", "public"];
 var CSS_FILE_CAP = 200;
+var DEFAULT_CSS_DEPTH = 10;
 function toRelative(root, abs) {
-  const rel = path5.relative(root, abs);
-  return rel.split(path5.sep).join("/");
+  const rel = path8.relative(root, abs);
+  return rel.split(path8.sep).join("/");
 }
-function detectCssFiles(root) {
-  const found = [];
+function detectCssFiles(root, scanRoots = [], maxDepth = DEFAULT_CSS_DEPTH) {
+  const base = path8.resolve(root);
+  const found = /* @__PURE__ */ new Map();
   let capped = false;
-  const walk = (dir) => {
-    if (capped) return;
+  const walk = (dir, depth) => {
+    if (capped || depth > maxDepth) return;
     let entries;
     try {
       entries = fs2.readdirSync(dir, { withFileTypes: true });
@@ -6345,32 +7172,40 @@ function detectCssFiles(root) {
       return;
     }
     for (const entry of entries) {
-      const full = path5.join(dir, entry.name);
+      const full = path8.join(dir, entry.name);
       if (entry.isDirectory()) {
         if (SKIP_DIRS2.has(entry.name)) continue;
-        walk(full);
+        walk(full, depth + 1);
         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;
+        const abs = path8.resolve(full);
+        if (!found.has(abs)) {
+          found.set(abs, toRelative(base, abs));
+          if (found.size >= CSS_FILE_CAP) {
+            capped = true;
+            return;
+          }
         }
       }
     }
   };
-  walk(path5.resolve(root));
-  found.sort((a, b3) => a.localeCompare(b3));
+  walk(base, 0);
+  for (const r2 of scanRoots) {
+    if (capped) break;
+    const abs = path8.resolve(r2);
+    if (abs !== base) walk(abs, 0);
+  }
+  const list = [...found.values()].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;
+  return list;
 }
 function detectInputDirs(root) {
-  const resolved = path5.resolve(root);
+  const resolved = path8.resolve(root);
   return COMMON_INPUT_DIRS.filter((name) => {
     try {
-      return fs2.statSync(path5.join(resolved, name)).isDirectory();
+      return fs2.statSync(path8.join(resolved, name)).isDirectory();
     } catch {
       return false;
     }
@@ -6446,15 +7281,6 @@ async function runWizard(base) {
   } else if (outputMode === "overwrite") {
     dangerouslyOverwriteSource = true;
   }
-  const allPasses = builtinPatternNames();
-  const passSelection = await fe({
-    message: "Which optimization passes should run?",
-    options: allPasses.map((name) => ({ value: name, label: name })),
-    initialValues: [...allPasses],
-    required: true
-  });
-  if (cancelled(passSelection)) return done();
-  const passes = passSelection;
   const provider = await ve({
     message: "How should class names resolve to styles?",
     options: [
@@ -6467,7 +7293,7 @@ async function runWizard(base) {
   if (cancelled(provider)) return done();
   let css = base.css;
   if (provider === "custom") {
-    const detectedCss = detectCssFiles(root);
+    const detectedCss = detectCssFiles(root, [inputPath]);
     if (detectedCss.length > 0) {
       const picked = await fe({
         message: "Which CSS files should resolve your classes? (all detected files are pre-selected)",
@@ -6495,7 +7321,7 @@ async function runWizard(base) {
     css,
     dryRun,
     dangerouslyOverwriteSource,
-    passes: passes.length === allPasses.length ? null : passes,
+    passes: null,
     safety: base.safety ?? DEFAULT_SAFETY
   };
   function done() {
@@ -6505,13 +7331,6 @@ async function runWizard(base) {
 }
 
 // ../cli/src/index.ts
-function addStats(totals, stats, changed) {
-  totals.files += 1;
-  if (changed) totals.changed += 1;
-  totals.nodesRemoved += stats.nodesRemoved;
-  totals.classesSaved += stats.classesSaved;
-  totals.bytesSaved += stats.bytesSaved;
-}
 function printReport(totals) {
   console.log("");
   console.log("domflax report");
@@ -6521,28 +7340,13 @@ function printReport(totals) {
   console.log(`  classes saved   : ${totals.classesSaved}`);
   console.log(`  bytes saved     : ${totals.bytesSaved}`);
 }
-async function execute(options) {
-  const { files, inputRoot, warnings } = discoverInputs(options.paths);
-  for (const w2 of warnings) console.error(`domflax: ${w2}`);
-  if (files.length === 0) {
-    console.error("domflax: no .jsx/.tsx/.html files found for the given paths");
-    return { exitCode: 1 };
-  }
-  const projectRoot = options.projectRoot ?? process.cwd();
-  const gitClean = options.dangerouslyOverwriteSource && !options.noGitCheck ? isGitClean(projectRoot) : true;
-  const planned = planWrites(options, gitClean);
-  if (!planned.ok) {
-    console.error(`domflax: ${planned.error}`);
-    return { exitCode: 1 };
-  }
-  const plan = planned.value;
+function runInline(files, options, inputRoot, plan, totals) {
   const transform = createTransform(options);
-  const totals = { files: 0, changed: 0, nodesRemoved: 0, classesSaved: 0, bytesSaved: 0 };
   let failures = 0;
   for (const file of files) {
     let code;
     try {
-      code = (0, import_node_fs2.readFileSync)(file, "utf8");
+      code = (0, import_node_fs4.readFileSync)(file, "utf8");
     } catch (err) {
       console.error(`domflax: cannot read ${file}: ${String(err?.message ?? err)}`);
       failures += 1;
@@ -6551,7 +7355,7 @@ async function execute(options) {
     const result = transform.transformFile(code, file);
     addStats(totals, result.stats, result.changed);
     if (options.dryRun) {
-      const rel = path6.relative(inputRoot, file) || path6.basename(file);
+      const rel = path9.relative(inputRoot, file) || path9.basename(file);
       if (result.changed) console.log(unifiedDiff(code, result.code, rel));
       else if (!options.report) console.log(`  (unchanged) ${rel}`);
       continue;
@@ -6564,16 +7368,67 @@ async function execute(options) {
       continue;
     }
     try {
-      (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 ${path6.relative(process.cwd(), target.value) || target.value}`);
+      (0, import_node_fs4.mkdirSync)(path9.dirname(target.value), { recursive: true });
+      (0, import_node_fs4.writeFileSync)(target.value, result.code, "utf8");
+      console.log(`domflax: wrote ${path9.relative(process.cwd(), target.value) || target.value}`);
     } catch (err) {
       console.error(`domflax: cannot write ${target.value}: ${String(err?.message ?? err)}`);
       failures += 1;
     }
   }
+  return failures;
+}
+async function execute(options) {
+  const { files, inputRoot, warnings } = discoverInputs(options.paths);
+  for (const w2 of warnings) console.error(`domflax: ${w2}`);
+  if (files.length === 0) {
+    console.error("domflax: no .jsx/.tsx files found for the given paths");
+    return { exitCode: 1 };
+  }
+  const projectRoot = options.projectRoot ?? process.cwd();
+  const gitClean = options.dangerouslyOverwriteSource && !options.noGitCheck ? isGitClean(projectRoot) : true;
+  const planned = planWrites(options, gitClean);
+  if (!planned.ok) {
+    console.error(`domflax: ${planned.error}`);
+    return { exitCode: 1 };
+  }
+  const plan = planned.value;
+  const poolPlan = computeWorkerCount(options);
+  const usePool = !options.dryRun && shouldUsePool(files.length, poolPlan);
+  const totals = emptyTotals();
+  let failures = 0;
+  if (usePool) {
+    const outcome = await runPool(
+      files,
+      { options, inputRoot, plan },
+      poolPlan
+      // Per-file "wrote" lines are collected and printed in deterministic (sorted) order below.
+    );
+    Object.assign(totals, outcome.totals);
+    failures = outcome.failures;
+    for (const { path: p2, error } of outcome.errors) {
+      console.error(`domflax: failed ${path9.relative(process.cwd(), p2) || p2}: ${error}`);
+    }
+    for (const dest of [...outcome.wrote].sort()) {
+      console.log(`domflax: wrote ${path9.relative(process.cwd(), dest) || dest}`);
+    }
+  } else {
+    failures += runInline(files, options, inputRoot, plan, totals);
+  }
+  if (options.dryRun) {
+    console.log("\ndomflax: dry run \u2014 no files were written.");
+  } else if (totals.changed === 0) {
+    console.log(
+      `
+domflax: processed ${totals.files} file${totals.files === 1 ? "" : "s"} \u2014 nothing to optimize (0 changed).`
+    );
+  } else {
+    console.log(
+      `
+domflax: optimized ${totals.changed} of ${totals.files} file${totals.files === 1 ? "" : "s"} (${totals.nodesRemoved} nodes removed, ${totals.classesSaved} classes saved, ${totals.bytesSaved} bytes saved).`
+    );
+  }
   if (options.report) printReport(totals);
-  if (options.dryRun) console.log("\ndomflax: dry run \u2014 no files were written.");
   return { exitCode: failures > 0 ? 1 : 0 };
 }
 async function main(argv = process.argv.slice(2)) {