domflax 0.1.0 → 0.1.1

package/dist/{chunk-77SLHRN6.js → chunk-DWLB7FRR.js}

@@ -227,7 +227,7 @@ function walk(doc, visitor) {
   visit(doc.root, 0);
 }
 
-// ../core/src/ops.ts
+// ../core/src/ops/runtime.ts
 init_esm_shims();
 function cloneStyleMap(sm) {
   const blocks = /* @__PURE__ */ new Map();
@@ -295,6 +295,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();
@@ -403,6 +429,9 @@ function mergeStyleMaps(target, source, policy) {
   }
   return { map: { blocks }, conflict };
 }
+
+// ../core/src/ops/apply.ts
+init_esm_shims();
 function safetyOk(state, op, targetId) {
   const opSafety = op.origin.safety;
   if (opSafety > state.ceiling) {
@@ -629,32 +658,6 @@ function applyFold(state, op) {
   for (const d of issues) state.diagnostics.push(d);
   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 = {
@@ -732,15 +735,11 @@ function finalize(state) {
   };
 }
 
-// ../core/src/pass-manager.ts
+// ../core/src/ops.ts
+init_esm_shims();
+
+// ../core/src/pass-context.ts
 init_esm_shims();
-var DEFAULT_FIXPOINT = {
-  maxIterations: 16,
-  phases: { flatten: 16, compress: 8, extract: 4 },
-  onBudgetExhausted: "warn",
-  detectOscillation: true
-};
-var PHASE_ORDER = ["flatten", "compress", "extract"];
 function createNullResolver() {
   const empty = {
     styles: emptyStyleMap(),
@@ -985,6 +984,134 @@ function buildMatchContext(doc, elementId, resolver, selectors, safety, phase, i
     }
   };
 }
+
+// ../core/src/flatten-safety.ts
+init_esm_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 d = block.decls.get(prop);
+  return d != null && String(d.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 d = block.decls.get(DISPLAY);
+      if (d) return String(d.value);
+    }
+  }
+  return "";
+}
+function newParentIsFlexOrGrid(before, wrapper, norm) {
+  if (wrapper.parent == null) return false;
+  const p = before.nodes.get(wrapper.parent);
+  if (!p || p.kind !== "element") return false;
+  return FLEX_GRID_DISPLAYS.has(displayOf(p, 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 d = block.decls.get(prop);
+      if (!d || NEUTRAL_ALIGN.has(String(d.value))) continue;
+      const prev = before?.blocks.get(ck)?.decls.get(prop);
+      if (!prev || String(prev.value) !== String(d.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
+init_esm_shims();
+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, pattern2) {
   return {
     ...draft,
@@ -1040,69 +1167,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 pattern2 of patterns) {
+    if (pattern2.safety > ctx.safetyCeiling) continue;
+    let drafts = [];
+    try {
+      const mctx = buildMatchContext(doc, elId, ctx.resolver, ctx.selectors, ctx.safetyCeiling, phase, iteration);
+      const result = pattern2.evaluate(mctx, factory);
+      if (!result) continue;
+      drafts = result.ops;
+      if (result.diagnostics) for (const d of result.diagnostics) diagnostics.push(d);
+    } 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
+      });
+      continue;
+    }
+    if (drafts.length === 0) continue;
+    return { ops: drafts.map((d) => stampOrigin(d, pattern2)), pattern: pattern2 };
+  }
+  return null;
+}
+function revertDiagnostic(pattern2, elId, phase, iteration, resolverId) {
+  return {
+    code: "DF_VERIFY_REVERTED",
+    severity: "warn",
+    message: `flatten '${pattern2.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: pattern2.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 d of result.diagnostics) diagnostics.push(d);
-      } 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: pattern2 } = evaluated;
+    const outcome = applyOps(state.doc, ops, ctx);
+    for (const d of outcome.result.diagnostics) diagnostics.push(d);
+    if (outcome.result.appliedGroups === 0) continue;
+    if (phase === "flatten") {
+      const verdict = flattenVerdict(state.doc, outcome.doc, ops, ctx);
+      if (verdict !== "commit") {
+        diagnostics.push(revertDiagnostic(pattern2, elId, phase, iteration, ctx.resolver.id));
+        flattenBarred.add(elId);
         continue;
       }
-      if (drafts.length === 0) continue;
-      const ops = drafts.map((d) => stampOrigin(d, pattern2));
-      const outcome = applyOps(state.doc, ops, ctx);
-      for (const d of outcome.result.diagnostics) diagnostics.push(d);
-      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;
 }
@@ -1117,6 +1251,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();
@@ -1125,76 +1279,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 };
 }
@@ -1431,40 +1563,6 @@ function syncClassesFromComputed(doc, resolver, norm) {
 // ../core/src/index.ts
 init_esm_shims();
 
-// ../pattern-kit/src/define.ts
-init_esm_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/normalize.ts
 init_esm_shims();
 var INHERITED_PROPERTIES = [
@@ -1812,6 +1910,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;
@@ -1852,6 +1955,42 @@ function removeNode(target) {
 
 // ../pattern-kit/src/pattern.ts
 init_esm_shims();
+
+// ../pattern-kit/src/define.ts
+init_esm_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, (m) => `-${m.toLowerCase()}`);
@@ -1888,8 +2027,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(m) {
   const parts = [isElement(m.tag)];
@@ -1905,7 +2056,8 @@ function compileDeclarativeMatch(m) {
 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) {
@@ -1962,7 +2114,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 = {
@@ -1972,7 +2124,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);
@@ -1980,8 +2132,9 @@ function pattern(config) {
       return { ops };
     }
   };
-  return definePattern(spec);
+  return validatePattern(spec);
 }
+var pattern = definePattern;
 
 // ../pattern-kit/src/index.ts
 init_esm_shims();
@@ -2012,17 +2165,27 @@ export {
   cloneDocument,
   applyOps,
   applyGroups,
-  DEFAULT_FIXPOINT,
   createNullResolver,
   createNullSelectorIndex,
   buildSelectorIndex,
   createRewriteFactory,
+  buildMatchContext,
+  classifyFlattenOps,
+  DEFAULT_FIXPOINT,
+  PHASE_ORDER,
+  stampOrigin,
+  patternsForPhase,
+  flattenWouldDropStyle,
+  flattenVerdict,
+  evaluateElement,
+  revertDiagnostic,
+  docFingerprint,
+  finalizePhase,
   runPasses,
   createPassManager,
   createSyntheticSink,
   createPipeline,
   syncClassesFromComputed,
-  definePattern,
   createNormalizer,
   normalizer,
   isStyleSuperset,
@@ -2037,11 +2200,13 @@ export {
   hasEventHandlers,
   hasDynamicChildren,
   hasDynamicClasses,
+  opaque,
   targetedByCombinator,
   mergeStyle,
   foldInheritedStyles,
   replaceWith,
   removeNode,
+  definePattern,
   pattern
 };
-//# sourceMappingURL=chunk-77SLHRN6.js.map
+//# sourceMappingURL=chunk-DWLB7FRR.js.map