domflax 0.1.0 → 0.1.2

package/dist/index.d.ts

@@ -1,16 +1,14 @@
-import { n as IRDocument, J as ApplyResult, K as RewriteGroup, L as ApplyContext, O as RewriteOp, Q as FixpointConfig, T as StyleResolver, U as SelectorIndex, W as Pass, X as PassManager, x as RewriteFactory, Y as PhaseRunResult, Z as Pipeline, _ as SyntheticSink, c as StyleNormalizer, w as Captures, P as Pattern, v as SafetyLevel, $ as EncodedSourceMap } from './types-BQ7l6dVe.js';
-export { a0 as AppliedOp, A as AttrMap, a1 as AttrValue, a2 as Backend, a3 as BackendContext, k as Backref, B as BackrefTable, a4 as Brand, g as ClassList, a5 as ClassListForm, a6 as ClassSegment, a7 as ClassToken, a8 as CodegenResult, a9 as CommentSpec, e as ConditionKey, C as CssProperty, aa as CssValue, ab as DeclSignature, ac as DeepReadonly, H as Diagnostic, ad as DiagnosticCode, ae as DistributiveOmit, af as EditPlan, E as ElementLike, ag as ElementSpec, ah as EmitContext, ai as EmitResult, aj as ExprKind, ak as ExprRecord, p as ExprRef, r as ExprRegistry, al as ExprSpec, am as FileKind, an as FragmentSpec, ao as Frontend, ap as FrontendConfig, F as FrontendKind, aq as FrontendParseContext, ar as HaltReason, m as IRComment, o as IRElement, q as IRExpr, s as IRFragment, f as IRNamespace, l as IRNode, as as IRNodeBase, I as IRNodeId, at as IRNodeKind, u as IRText, t as IdAllocator, au as InheritedPropertyTable, h as InlineStyle, M as MatchContext, y as MatchResult, N as NodeLike, j as NodeMeta, av as NodeRefSpec, b as NodeSpec, aw as OpOrigin, ax as OpValidationIssue, ay as OpaqueReason, az as OpaqueToken, aA as ParentLayoutContext, aB as ParseResult, z as PassCategory, aC as PassPhase, aD as PassTraceEntry, G as PatternDoc, aE as PatternName, aF as PipelineConfig, aG as PipelineInput, aH as PipelineOutput, aI as PipelineStats, aJ as Position, D as PreconditionSketch, aK as ReindentSpec, aL as Reporter, aM as ResolveInput, aN as ResolveResult, aO as ResolverDiagnostic, aP as RewriteContext, R as RewriteOpDraft, aQ as SelectorUsage, aR as Severity, aS as SkippedOpGroup, aT as SourceFile, aU as SourceFileId, i as SourceSpan, aV as StructuralInverse, aW as StyleBlock, d as StyleCondition, a as StyleConflictPolicy, aX as StyleDecl, S as StyleMap, aY as StyleOrigin, aZ as StylePredicate, a_ as SyntheticClass, a$ as TextEdit, b0 as TextSpec, b1 as TreeShapeSketch, b2 as VisitContext, b3 as VisitSignal, V as Visitor } from './types-BQ7l6dVe.js';
-import { A as AuthoredPattern } from './pattern-CX6iBzTD.js';
-export { B as BASE_CONDITION, u as BASE_CONDITION_KEY, v as ElementInit, w as MutableBackrefTable, x as childIds, y as conditionKey, z as createBackrefTable, C as createComment, G as createDocument, H as createElement, I as createExpr, J as createExprRegistry, K as createFragment, L as createIdAllocator, N as createText, O as defaultMeta, Q as elementIds, S as emptyAttrMap, T as emptyClassList, U as emptyInlineStyle, i as emptyStyleMap, V as getElement, W as getNode, X as walk } from './pattern-CX6iBzTD.js';
+import { e as IRDocument, d as RewriteOp, I as IRNodeId, h as StyleResolver, g as SelectorIndex, f as SafetyLevel, l as PassPhase, r as RewriteFactory, i as Diagnostic, c as StyleNormalizer, R as RewriteOpDraft, j as SyntheticSink } from './resolve-ops-DIwEelH-.js';
+export { A as AttrMap, Q as AttrValue, y as Backref, B as BackrefTable, T as Brand, w as ClassList, U as ClassListForm, W as ClassSegment, X as ClassToken, Y as CommentSpec, u as ConditionKey, C as CssProperty, Z as CssValue, _ as DeclSignature, o as DeepReadonly, D as DiagnosticCode, $ as DistributiveOmit, E as ElementLike, a0 as ElementSpec, a1 as EmitContext, a2 as EmitResult, a3 as ExprKind, a4 as ExprRecord, H as ExprRef, K as ExprRegistry, a5 as ExprSpec, F as FileKind, a6 as FragmentSpec, G as FrontendKind, z as IRComment, p as IRElement, J as IRExpr, L as IRFragment, v as IRNamespace, q as IRNode, a7 as IRNodeBase, a8 as IRNodeKind, O as IRText, M as IdAllocator, a9 as InheritedPropertyTable, x as InlineStyle, N as NodeLike, n as NodeMeta, aa as NodeRefSpec, b as NodeSpec, ab as OpOrigin, ac as OpaqueReason, ad as OpaqueToken, m as PassCategory, ae as PassTraceEntry, P as PatternName, af as Position, s as Reporter, ag as ResolveInput, ah as ResolveResult, ai as ResolverDiagnostic, aj as SelectorUsage, ak as Severity, al as SourceFile, am as SourceFileId, k as SourceSpan, an as StyleBlock, t as StyleCondition, a as StyleConflictPolicy, ao as StyleDecl, S as StyleMap, ap as StyleOrigin, aq as SyntheticClass, ar as TextSpec, as as VisitContext, at as VisitSignal, V as Visitor } from './resolve-ops-DIwEelH-.js';
+import { y as ApplyResult, z as RewriteGroup, B as ApplyContext, C as MatchContext, E as FixpointConfig, H as HaltReason, G as Pass, I as PassManager, J as Pattern, K as PhaseRunResult, L as Pipeline, A as AuthoredPattern, N as Captures, O as EncodedSourceMap } from './pattern-CV607P87.js';
+export { Q as AppliedOp, S as BASE_CONDITION, U as BASE_CONDITION_KEY, V as Backend, W as BackendContext, X as CodegenResult, Y as EditPlan, Z as ElementInit, _ as FlattenGate, $ as Frontend, a0 as FrontendConfig, a1 as FrontendParseContext, a2 as MatchResult, a3 as MutableBackrefTable, a4 as OpValidationIssue, a5 as ParentLayoutContext, a6 as ParseResult, a7 as PatternDoc, a8 as PipelineConfig, a9 as PipelineInput, aa as PipelineOutput, ab as PipelineStats, ac as PreconditionSketch, ad as ReindentSpec, ae as RewriteContext, af as SkippedOpGroup, ag as StructuralInverse, ah as StylePredicate, ai as TextEdit, aj as TreeShapeSketch, ak as childIds, al as conditionKey, am as createBackrefTable, an as createComment, ao as createDocument, ap as createElement, aq as createExpr, ar as createExprRegistry, as as createFragment, at as createIdAllocator, au as createText, av as defaultMeta, aw as elementIds, ax as emptyAttrMap, ay as emptyClassList, az as emptyInlineStyle, l as emptyStyleMap, aA as getElement, aB as getNode, aC as walk } from './pattern-CV607P87.js';
 
 /**
- * @domflax/core — the pure applier (the one trusted mutator).
+ * @domflax/core — applier runtime helpers (shared by the per-op handlers in `./apply`).
  *
- * {@link applyOps} takes an {@link IRDocument} plus a flat list of {@link RewriteOp}s and returns
- * a NEW, mutated document (the input document is left untouched — "pure" in the input-immutability
- * sense). Every op is validated against the safety ceiling and node-local safety floor before it
- * runs; rejected ops are collected into {@link ApplyResult.skipped} with {@link Diagnostic}s rather
- * than throwing. Dependency-free: only the `./types` contract and `./builders` runtime helpers.
+ * Pure, dependency-free building blocks for the trusted mutator: input-preserving cloning, the
+ * mutable apply state, small tree helpers, detached-spec materialization, and style merging.
+ * Only depends on the `../types` contract and `../builders` runtime helpers.
  */
 
 interface ApplyOutcome {
@@ -20,6 +18,15 @@ interface ApplyOutcome {
 }
 /** Shallow-immutable clone: input doc and its node objects are never mutated. */
 declare function cloneDocument(doc: IRDocument): IRDocument;
+
+/**
+ * @domflax/core — the per-op handlers + public apply entry points.
+ *
+ * {@link applyOps} validates each {@link RewriteOp} against the safety ceiling / node-local floor
+ * and commits it to a clone of the document; {@link applyGroups} commits whole {@link RewriteGroup}s
+ * atomically. Rejected ops are collected into {@link ApplyResult.skipped} rather than throwing.
+ */
+
 /**
  * Apply a flat list of ops to a copy of `doc`. The input document is never mutated.
  * Each op is independently validated; failing ops are skipped (collected in
@@ -32,17 +39,6 @@ declare function applyOps(doc: IRDocument, ops: readonly RewriteOp[], ctx?: Part
  */
 declare function applyGroups(doc: IRDocument, groups: readonly RewriteGroup[], ctx?: Partial<ApplyContext>): ApplyOutcome;
 
-/**
- * @domflax/core — pass manager + supporting contexts.
- *
- * Runs {@link Pattern}s grouped by {@link PassCategory} in declared order, driving the `flatten`
- * phase to a fixpoint under a max-iteration budget, and isolating per-node pattern errors into
- * {@link Diagnostic}s (a thrown pattern never aborts the run — it becomes `DF_PATTERN_THREW`).
- *
- * Dependency-free: only the `./types` contract plus `./builders` + `./ops` runtime helpers.
- */
-
-declare const DEFAULT_FIXPOINT: FixpointConfig;
 /** A no-op resolver: owns nothing, resolves to empty styles. Useful as an injection default. */
 declare function createNullResolver(): StyleResolver;
 /** A SelectorIndex that reports zero CSS-targeting (no combinator/structural coupling). */
@@ -63,10 +59,75 @@ declare function createNullSelectorIndex(): SelectorIndex;
 declare function buildSelectorIndex(doc: IRDocument, resolver: StyleResolver): SelectorIndex;
 /** The pattern-kit factory: produces op DRAFTS and detached NodeSpecs without any allocation. */
 declare function createRewriteFactory(): RewriteFactory;
+/** Build the read-only {@link MatchContext} a pattern's `evaluate` receives for one element. */
+declare function buildMatchContext(doc: IRDocument, elementId: IRNodeId, resolver: StyleResolver, selectors: SelectorIndex, safety: SafetyLevel, phase: PassPhase, iteration: number): MatchContext;
+
 /**
- * Runs `passes` over `doc` to a per-phase fixpoint. This is the concrete entry the pipeline calls
- * (the {@link PassManager} interface keeps passes on the call site; we accept them explicitly here
- * so the manager stays stateless).
+ * @domflax/core — pass manager (the sync, static flatten driver).
+ *
+ * Runs {@link Pattern}s grouped by {@link PassPhase} in declared order, driving the `flatten` phase to
+ * a fixpoint under a max-iteration budget, isolating per-node pattern errors into {@link Diagnostic}s
+ * (a thrown pattern never aborts the run — it becomes `DF_PATTERN_THREW`), and applying the static
+ * flatten policy ({@link ApplyContext.gate}) — under `'provably-safe'` only provably layout-neutral
+ * flattens commit, so the transform never changes rendering and never launches a browser.
+ *
+ * The supporting contexts (resolvers, selector index, rewrite factory, match context) live in
+ * `./pass-context`; the static flatten classifier in `./flatten-safety`. Dependency-free: only the
+ * `./types` contract + sibling runtime helpers.
+ */
+
+declare const DEFAULT_FIXPOINT: FixpointConfig;
+declare const PHASE_ORDER: readonly PassPhase[];
+declare function stampOrigin(draft: RewriteOpDraft, pattern: Pattern): RewriteOp;
+declare function patternsForPhase(passes: readonly Pass[], phase: PassPhase): Pattern[];
+interface RunState {
+    doc: IRDocument;
+}
+/**
+ * T5 — flatten must never DROP a style it can't reproduce. After a flatten transfers declarations onto
+ * a surviving (rewritable) element, if the resolver can no longer EXACTLY reverse-emit that element's
+ * computed style — and it could before — the flatten would silently lose the residual declarations
+ * during reverse-emit, so the whole flatten is reverted (the wrapper is kept). Pre-existing residue
+ * (already non-exact before the flatten) is not blamed on the flatten and does not trigger a revert.
+ */
+declare function flattenWouldDropStyle(before: IRDocument, after: IRDocument, ops: readonly RewriteOp[], resolver: StyleResolver, normalizer: StyleNormalizer): boolean;
+type FlattenVerdict = 'commit' | 'revert';
+/**
+ * Decide what to do with a freshly-applied flatten op-group, given the gate. Returns:
+ *   • `'commit'` — keep the outcome (the historical path for `'all'`, and provably-safe flattens).
+ *   • `'revert'` — discard + bar the node (residual-drop, or a needs-verification flatten under the
+ *                  `'provably-safe'` gate).
+ *
+ * `before`/`after` are the docs immediately around the group's application.
+ */
+declare function flattenVerdict(before: IRDocument, after: IRDocument, ops: readonly RewriteOp[], ctx: ApplyContext): FlattenVerdict;
+/**
+ * Evaluate every pattern against `elId` until one produces ops; returns the stamped op list (and its
+ * pattern), or null when no pattern matched. Pattern throws become `DF_PATTERN_THREW` diagnostics.
+ */
+declare function evaluateElement(doc: IRDocument, elId: IRNodeId, patterns: readonly Pattern[], ctx: ApplyContext, factory: RewriteFactory, phase: PassPhase, iteration: number, diagnostics: Diagnostic[]): {
+    ops: RewriteOp[];
+    pattern: Pattern;
+} | null;
+/** Emit the diagnostic recorded when a flatten is reverted by the gate / residual guard. */
+declare function revertDiagnostic(pattern: Pattern, elId: IRNodeId, phase: PassPhase, iteration: number, resolverId: string): Diagnostic;
+/** Cheap structural fingerprint of the document for oscillation detection. */
+declare function docFingerprint(doc: IRDocument): string;
+/** A single phase's terminal result, built from the loop's accounting. */
+interface PhaseLoopState {
+    iterations: number;
+    converged: boolean;
+    haltReason: HaltReason;
+    readonly touched: Set<IRNodeId>;
+    readonly diagnostics: Diagnostic[];
+    readonly seen: Set<string>;
+}
+/** Record the budget-exhausted diagnostic + finalize a phase result. Shared by sync + async drivers. */
+declare function finalizePhase(phase: PassPhase, s: PhaseLoopState, budget: number, onBudgetExhausted: 'warn' | 'error'): PhaseRunResult;
+/**
+ * Runs `passes` over `doc` to a per-phase fixpoint (synchronous). This is the concrete entry the
+ * pipeline calls. Under the `'provably-safe'` gate, flattens that are not provably layout-neutral are
+ * reverted — the transform is fully static and never changes rendering.
  */
 declare function runPasses(doc: IRDocument, passes: readonly Pass[], ctx: ApplyContext, config?: FixpointConfig): {
     readonly doc: IRDocument;
@@ -75,6 +136,49 @@ declare function runPasses(doc: IRDocument, passes: readonly Pass[], ctx: ApplyC
 /** A {@link PassManager} that runs the given passes (carried on the manager instance). */
 declare function createPassManager(passes: readonly Pass[]): PassManager;
 
+/**
+ * @domflax/core — static classification of a flatten (the VERIFIER-GATED safety core).
+ *
+ * A flatten pattern matches on `paintsNothing` + a structural/style signature, but unwrapping a
+ * wrapper can still change rendering: a wrapper with non-paint layout styles (e.g. `px-4 py-4`) drops
+ * that padding when removed (it is NOT reproduced on the surviving child), and a centering wrapper
+ * collapsed to `place-self:center` only stays centered when the child's NEW parent is flex/grid. The
+ * existing emittability revert only checks the ADDED style is re-emittable — not that the wrapper's
+ * own styles survive, nor that the parent context holds.
+ *
+ * {@link classifyFlattenOps} answers, for one applied flatten op-group, whether it is:
+ *
+ *   • `'provably-safe'`       — removing the wrapper changes NOTHING renderable: the wrapper
+ *                                establishes no box/formatting/stacking context, has no non-inherited
+ *                                own declaration that the rewrite does not reproduce on the surviving
+ *                                child, AND the rewrite adds no parent-context-dependent self-alignment
+ *                                (unless the new parent is statically flex/grid). Examples: passthrough
+ *                                / empty-style / display-contents / redundant-fragment wrappers.
+ *   • `'needs-verification'`  — anything else (drops/relies on a style, or centering→place-self).
+ *
+ * Pure + dependency-free: only the `./types` contract + `./builders` accessors.
+ */
+
+/** The static verdict for one flatten op-group. */
+type FlattenClass = 'provably-safe' | 'needs-verification';
+/** A classified flatten plus the structural anchors a verifier needs to render before/after. */
+interface FlattenClassification {
+    readonly kind: FlattenClass;
+    /** The unwrapped wrapper (in the BEFORE doc), or null when the group removes no element box. */
+    readonly wrapperId: IRNodeId | null;
+    /** The surviving child styles fold onto (the AFTER subtree root), or null. */
+    readonly childId: IRNodeId | null;
+}
+/**
+ * Statically classify one applied flatten op-group. `before` is the doc as it was BEFORE the group's
+ * ops; `after` is the result of applying them.
+ *
+ * A group that unwraps no element box (e.g. {@link redundant-fragment}, or a style-only flatten) is
+ * `provably-safe` — there is no box whose removal could move/resize anything. Otherwise the three
+ * criteria above decide.
+ */
+declare function classifyFlattenOps(before: IRDocument, after: IRDocument, ops: readonly RewriteOp[], norm: StyleNormalizer): FlattenClassification;
+
 /**
  * @domflax/core — the pure, single-file pipeline.
  *
@@ -121,6 +225,36 @@ declare function createPipeline(): Pipeline;
  */
 declare function syncClassesFromComputed(doc: IRDocument, resolver: StyleResolver, norm: StyleNormalizer): void;
 
+/**
+ * @domflax/patterns — flatten pattern: `display-contents-wrapper`.
+ *
+ * Collapses a wrapper that has explicitly opted OUT of generating a box:
+ *
+ *   <div style="display:contents"><Child/></div>   →   <Child/>
+ *
+ * `display:contents` makes an element generate NO box of its own — its children render exactly as if
+ * they were direct children of the element's parent. A `display:contents` wrapper with a single
+ * element child is therefore already a layout passthrough: it contributes nothing to flow, paint
+ * (a contents box paints nothing), formatting, stacking, or containing-block resolution. Removing it
+ * and hoisting the child produces a tree that is layout-identical — the wrapper's only remaining
+ * effect was inheritance, which is preserved by folding inheritable declarations onto the child first.
+ *
+ * This is the safest possible wrapper-elimination: the box being removed provably did not exist.
+ * The opacity-barrier + selector-safety guards (ref/handlers/dynamic-children/raw-html/combinator/
+ * reparent-impact) are auto-applied for every `flatten/*` pattern; the `where` predicates add the
+ * passthrough-specific requirements (no own attrs / dynamic-or-spread classes, no `var()` coupling,
+ * not a component, not a structural-pseudo subject).
+ *
+ * (Chosen as the safe variant of the size-hoisting "full-size passthrough" idea: hoisting an explicit
+ * `width/height:100%` onto a child is only sound when the child is block-level and unsized, which is
+ * not knowable from the wrapper alone — whereas a `display:contents` box is a passthrough by definition.)
+ */
+/**
+ * Flatten a `display:contents` wrapper (a box that generates no box) into its sole element child,
+ * folding any inheritable styles down first so inherited values survive the removal.
+ */
+declare const displayContentsWrapper: AuthoredPattern<Captures>;
+
 /**
  * @domflax/patterns — flatten pattern: `empty-style-div`.
  *
@@ -135,11 +269,11 @@ declare function syncClassesFromComputed(doc: IRDocument, resolver: StyleResolve
  * a descendant might read. Its box is therefore indistinguishable from "not being there", so it can
  * be unwrapped into its sole child.
  *
- * Authored with the declarative {@link pattern} API. The opacity-barrier + selector-safety guards
- * (ref/handlers/dynamic-children/raw-html/combinator/reparent-impact) are applied automatically for
- * every `flatten/*` pattern; the `where` predicates below add the LAYOUT-neutrality requirements
- * specific to this pattern (no non-block display, no box/formatting/stacking context, no containing
- * block, no custom-property coupling, no structural-pseudo targeting).
+ * Authored with the declarative {@link definePattern} API. The opacity-barrier + selector-safety
+ * guards (ref/handlers/dynamic-children/raw-html/combinator/reparent-impact) are applied
+ * automatically for every `flatten/*` pattern; the `where` predicates below add the LAYOUT-neutrality
+ * requirements specific to this pattern (no non-block display, no box/formatting/stacking context, no
+ * containing block, no custom-property coupling, no structural-pseudo targeting).
  */
 /**
  * Flatten a layout-neutral, style-free `<div>` wrapper into its sole element child.
@@ -157,11 +291,11 @@ declare const emptyStyleDiv: AuthoredPattern<Captures>;
  * The wrapper only exists to center one element; once `place-self:center` lives on the child the
  * wrapper is pure structural noise and can go.
  *
- * Authored with the declarative {@link pattern} API: the match is the flex-centering computed-style
- * signature on a single-element-child `<div>` that paints nothing of its own; the recipe folds
- * inheritable styles onto the child, grants it `place-self:center`, then unwraps the wrapper
- * (id-preserving). The opacity-barrier + selector-safety guards are applied automatically by the
- * `pattern()` factory for every `flatten/*` pattern.
+ * Authored with the declarative {@link definePattern} API: the match is the flex-centering
+ * computed-style signature on a single-element-child `<div>` that paints nothing of its own; the
+ * recipe folds inheritable styles onto the child, grants it `place-self:center`, then unwraps the
+ * wrapper (id-preserving). The opacity-barrier + selector-safety guards are applied automatically by
+ * the `definePattern` factory for every `flatten/*` pattern.
  */
 /**
  * Flatten a flex-centering `<div>` wrapper into its sole element child, granting the child
@@ -169,6 +303,29 @@ declare const emptyStyleDiv: AuthoredPattern<Captures>;
  */
 declare const flexCenterWrapper: AuthoredPattern<Captures>;
 
+/**
+ * @domflax/patterns — flatten pattern: `inline-flex-center-wrapper`.
+ *
+ * Collapses the inline-flex flavour of the "centering wrapper" idiom
+ *
+ *   <div style="display:inline-flex; align-items:center; justify-content:center"><Child/></div>
+ *
+ * into its sole child, pushing the centering intent down onto the child as `place-self: center`.
+ * Like its block-level `flex-center-wrapper` sibling the wrapper only exists to center one element;
+ * once `place-self:center` lives on the child the wrapper is pure structural noise and can go.
+ *
+ * Authored with the declarative {@link definePattern} API: the match is the inline-flex-centering
+ * computed-style signature on a single-element-child `<div>` that paints nothing of its own; the
+ * recipe folds inheritable styles onto the child, grants it `place-self:center`, then unwraps the
+ * wrapper (id-preserving). The opacity-barrier + selector-safety guards are applied automatically by
+ * the `definePattern` factory for every `flatten/*` pattern.
+ */
+/**
+ * Flatten an inline-flex-centering `<div>` wrapper into its sole element child, granting the child
+ * `place-self:center`.
+ */
+declare const inlineFlexCenterWrapper: AuthoredPattern<Captures>;
+
 /**
  * @domflax/patterns — flatten pattern: `nested-flex-merge`.
  *
@@ -196,6 +353,33 @@ declare const flexCenterWrapper: AuthoredPattern<Captures>;
  */
 declare const nestedFlexMerge: AuthoredPattern<Captures>;
 
+/**
+ * @domflax/patterns — flatten pattern: `nested-grid-merge`.
+ *
+ * Collapses a redundant nesting of two grid containers
+ *
+ *   <div style="display:grid; gap:8px">
+ *     <div style="display:grid; grid-template-columns:1fr 1fr"> … </div>
+ *   </div>
+ *
+ * where the OUTER grid container's sole element child is ITSELF a grid container, into a single grid
+ * container carrying the union of both elements' grid declarations. The outer wrapper's box is then
+ * structural noise (it paints nothing and only establishes a grid context the merged child now also
+ * establishes), so it is removed.
+ *
+ * This is the grid analogue of `nested-flex-merge`. The declarative match is a grid `<div>` with a
+ * single element child painting nothing of its own (auto-guarded against opacity barriers / combinator
+ * targeting like every `flatten/*` pattern). The value-relational reasoning — the child must also be a
+ * (non-combinator) grid container, the wrapper must carry only transferable grid/inheritable
+ * declarations, and the two must not conflict on any shared grid property — lives in the `rewrite`
+ * op-draft factory escape hatch, which folds inherited styles, transfers the wrapper's grid
+ * declarations onto the child (target-wins), then unwraps the wrapper.
+ */
+/**
+ * Flatten a grid container whose sole child is a compatible grid container into a single container.
+ */
+declare const nestedGridMerge: AuthoredPattern<Captures>;
+
 /**
  * @domflax/patterns — flatten pattern: `passthrough-wrapper`.
  *
@@ -209,11 +393,11 @@ declare const nestedFlexMerge: AuthoredPattern<Captures>;
  * Such a `<div>` is pure DOM noise: removing it and hoisting the child is invisible to both paint
  * and layout.
  *
- * Authored with the declarative {@link pattern} API. The opacity-barrier + selector-safety guards
- * (ref/handlers/dynamic-children/raw-html/combinator/reparent-impact) are applied automatically for
- * every `flatten/*` pattern; the `where` predicates add the passthrough-specific requirements (no
- * box/formatting/stacking context, no own attrs, no dynamic/spread classes, not a component, not a
- * structural-pseudo subject).
+ * Authored with the declarative {@link definePattern} API. The opacity-barrier + selector-safety
+ * guards (ref/handlers/dynamic-children/raw-html/combinator/reparent-impact) are applied
+ * automatically for every `flatten/*` pattern; the `where` predicates add the passthrough-specific
+ * requirements (no box/formatting/stacking context, no own attrs, no dynamic/spread classes, not a
+ * component, not a structural-pseudo subject).
  */
 /**
  * Flatten a do-nothing `<div>` wrapper into its sole element child, folding any inheritable styles
@@ -245,6 +429,86 @@ declare const passthroughWrapper: AuthoredPattern<Captures>;
  */
 declare const redundantFragment: AuthoredPattern<Captures>;
 
+/**
+ * @domflax/patterns — flatten pattern: `redundant-inline-wrapper`.
+ *
+ * Collapses a purely-structural INLINE wrapper:
+ *
+ *   <span><Child/></span>            (display:inline, no own style)
+ *
+ * An inline `<span>` that paints nothing, establishes no box / formatting / stacking context, carries
+ * no attributes beyond an (optional) inert class, declares no custom properties, and holds exactly one
+ * element child is pure inline noise. An empty inline box merely wraps its child's box; removing it and
+ * hoisting the child leaves both paint and layout untouched (the surviving child folds the inheritable
+ * declarations the span carried).
+ *
+ * This is the inline sibling of `passthrough-wrapper` (which targets `<div>`): the same opacity-barrier
+ * + selector-safety guards are auto-applied by the `pattern()` factory for every `flatten/*` pattern;
+ * the `where` predicates add the inline-passthrough requirements (display must be the inline default,
+ * no box/formatting/stacking context or var coupling, no own attrs / dynamic-or-spread classes, not a
+ * component, not a structural-pseudo subject).
+ */
+/**
+ * Flatten a do-nothing inline `<span>` wrapper into its sole element child, folding any inheritable
+ * styles down first so inherited values survive the box removal.
+ */
+declare const redundantInlineWrapper: AuthoredPattern<Captures>;
+
+/**
+ * @domflax/patterns — compress pattern: `border-radius-shorthand`.
+ *
+ * Collapses an element whose four corner radii are expressed as separate longhand declarations and
+ * are ALL EQUAL into the single CSS `border-radius` shorthand:
+ *
+ *   border-top-left-radius:0.5rem; border-top-right-radius:0.5rem;
+ *   border-bottom-right-radius:0.5rem; border-bottom-left-radius:0.5rem
+ *     ⇒  border-radius:0.5rem                  (Tailwind `rounded-lg`)
+ *
+ * The IR's computed StyleMap keeps each corner as its own longhand (Tailwind's `rounded-tl-*` /
+ * `rounded-tr-*` / … each resolve to one corner property). This pass runs the collapse in reverse on
+ * the computed map ONLY when all four corners share one value — the single case that maps cleanly to
+ * a single Tailwind utility (the CSS 2-value `border-radius` form is DIAGONAL, which has no clean
+ * `rounded-*` edge utility, so per-corner differences are intentionally left alone). Rebuilding the
+ * map with one `border-radius` decl lets the minimizing reverse-emit pick the single `rounded-*`
+ * token covering all four corners instead of two edge tokens.
+ *
+ * Authored with the declarative {@link pattern} API: `definePattern` auto-applies the compress safety guards — a dynamic or opaque class list
+ * and combinator-subject selectors are excluded (a ref / event handler / dynamic child / dangerous
+ * HTML never blocks a class-only rewrite); the
+ * `rewriteClasses` recipe rebuilds the class StyleMap, declining (`null`) unless the four corners are
+ * present, concrete, equal, and share an `!important` flag.
+ */
+/** Fold four equal corner radii into the single `border-radius` shorthand. */
+declare const borderRadiusShorthand: AuthoredPattern<Captures>;
+
+/**
+ * @domflax/patterns — compress pattern: `border-shorthand`.
+ *
+ * Collapses an element whose four border-side WIDTHS are expressed as separate longhand declarations
+ * back into the shortest equivalent `border-width` shorthand:
+ *
+ *   border-top-width:2px; border-right-width:2px; border-bottom-width:2px; border-left-width:2px
+ *     ⇒  border-width:2px                      (Tailwind `border-2`)
+ *
+ *   border-top-width:2px; border-bottom-width:2px; border-left-width:4px; border-right-width:4px
+ *     ⇒  border-width:2px 4px                  (Tailwind `border-y-2 border-x-4`)
+ *
+ * Tailwind's per-side / per-axis width utilities (`border-t-*`, `border-x-*`, …) each resolve to the
+ * matching `border-*-width` longhand(s); the shared normalizer keeps them longhand. This pass runs
+ * the expansion in reverse on the computed map ONLY when the four widths fold cleanly into a 1- or
+ * 2-value form — i.e. `top===bottom` AND `left===right`. Rebuilding the map with one `border-width`
+ * shorthand lets the minimizing reverse-emit pick the single/paired utility (`border-2`, or
+ * `border-x-* border-y-*`) instead of four per-side tokens. Only WIDTH is folded — border style and
+ * color are independent longhands the resolver carries separately, so this never disturbs them.
+ *
+ * Authored with the declarative {@link pattern} API: `definePattern` auto-applies the compress safety guards — a dynamic or opaque class list
+ * and combinator-subject selectors are excluded (a ref / event handler / dynamic child / dangerous
+ * HTML never blocks a class-only rewrite); the `rewriteClasses`
+ * recipe rebuilds the class StyleMap, declining (`null`) unless the four widths fold cleanly.
+ */
+/** Compress an element's four equal/paired border-width longhands into the shortest shorthand. */
+declare const borderShorthand: AuthoredPattern<Captures>;
+
 /**
  * @domflax/patterns — compress pattern: `dedupe-classes`.
  *
@@ -265,8 +529,9 @@ declare const redundantFragment: AuthoredPattern<Captures>;
  *     is NOT the winning `origin` of any declaration across ANY style condition. Such a token can
  *     be deleted with zero effect on the computed style.
  *
- * Authored with the declarative {@link pattern} API: the `where` guards exclude opacity barriers,
- * dynamic/opaque class lists, and combinator subjects; the `dropClasses` recipe returns the set of
+ * Authored with the declarative {@link pattern} API: `definePattern` auto-applies the compress safety guards — a dynamic or opaque class list
+ * and combinator-subject selectors are excluded (a ref / event handler / dynamic child / dangerous
+ * HTML never blocks a class-only rewrite); the `dropClasses` recipe returns the set of
  * fully-overridden, resolver-droppable tokens to delete (their `shadowed` provenance is pruned
  * automatically before the minimal class StyleMap is re-installed).
  */
@@ -276,6 +541,29 @@ declare const redundantFragment: AuthoredPattern<Captures>;
  */
 declare const dedupeClasses: AuthoredPattern<Captures>;
 
+/**
+ * @domflax/patterns — compress pattern: `gap-shorthand`.
+ *
+ * Collapses an element whose grid/flex gutters are expressed as two equal axis longhands back into
+ * the single `gap` shorthand:
+ *
+ *   row-gap:16px; column-gap:16px   ⇒   gap:16px            (Tailwind `gap-x-4 gap-y-4` → `gap-4`)
+ *
+ * The IR's computed StyleMap is canonically LONGHAND (the shared normalizer expands the `gap`
+ * shorthand into `row-gap` + `column-gap` at parse time). This pass runs the expansion in reverse on
+ * the computed map ONLY when both axes carry the SAME value and `!important` flag — i.e. when the two
+ * gutters genuinely fold into a single-value `gap`. When the axes differ it declines, leaving the two
+ * longhands verbatim (an asymmetric gutter has no equivalent single-value shorthand).
+ *
+ * Authored with the declarative {@link pattern} API: `definePattern` auto-applies the compress safety guards — a dynamic or opaque class list
+ * and combinator-subject selectors are excluded (a ref / event handler / dynamic child / dangerous
+ * HTML never blocks a class-only rewrite); the
+ * `rewriteClasses` recipe rebuilds the class StyleMap, declining (`null`) unless the two axis gaps
+ * are present, equal, and share an `!important` flag.
+ */
+/** Fold an equal `row-gap`/`column-gap` pair into the single `gap` shorthand. */
+declare const gapShorthand: AuthoredPattern<Captures>;
+
 /**
  * @domflax/patterns — compress pattern: `inset-shorthand`.
  *
@@ -290,8 +578,9 @@ declare const dedupeClasses: AuthoredPattern<Captures>;
  * collapses only the block axis and keeps the `left`/`right` longhands verbatim. When nothing
  * collapses (all four distinct, or fewer than a full pair present) the pattern declines.
  *
- * Authored with the declarative {@link pattern} API: the `where` guards exclude opacity barriers,
- * dynamic class lists, and combinator subjects; the `rewriteClasses` recipe rebuilds the class
+ * Authored with the declarative {@link pattern} API: `definePattern` auto-applies the compress safety guards — a dynamic or opaque class list
+ * and combinator-subject selectors are excluded (a ref / event handler / dynamic child / dangerous
+ * HTML never blocks a class-only rewrite); the `rewriteClasses` recipe rebuilds the class
  * StyleMap, declining (`null`) unless at least one inset axis collapses.
  */
 /**
@@ -319,8 +608,9 @@ declare const insetShorthand: AuthoredPattern<Captures>;
  * It is a pure representation change: the resolved box model is identical, only the declaration
  * count shrinks from four to one, which the backend can then re-emit as a single shorthand utility.
  *
- * Authored with the declarative {@link pattern} API: the `where` guards exclude opacity barriers,
- * dynamic class lists, and combinator subjects; the `rewriteClasses` recipe rebuilds the class
+ * Authored with the declarative {@link pattern} API: `definePattern` auto-applies the compress safety guards — a dynamic or opaque class list
+ * and combinator-subject selectors are excluded (a ref / event handler / dynamic child / dangerous
+ * HTML never blocks a class-only rewrite); the `rewriteClasses` recipe rebuilds the class
  * StyleMap, declining (`null`) unless all four margin longhands are present with a uniform
  * (non-)`!important` flag.
  */
@@ -329,6 +619,56 @@ declare const insetShorthand: AuthoredPattern<Captures>;
  */
 declare const marginShorthand: AuthoredPattern<Captures>;
 
+/**
+ * @domflax/patterns — compress pattern: `overflow-shorthand`.
+ *
+ * Collapses an element whose two overflow axes are expressed as equal longhands back into the single
+ * `overflow` shorthand:
+ *
+ *   overflow-x:auto; overflow-y:auto   ⇒   overflow:auto   (Tailwind `overflow-x-auto overflow-y-auto`
+ *                                                            → `overflow-auto`)
+ *
+ * Unlike the box shorthands, the shared normalizer leaves `overflow-x` / `overflow-y` as independent
+ * longhands (it does not synthesize an `overflow` shorthand), so an element styled with two equal
+ * axis utilities keeps two separate declarations until this pass folds them. The fold runs ONLY when
+ * both axes carry the SAME value and `!important` flag; an asymmetric pair (`overflow-x !==
+ * overflow-y`) has no single-keyword `overflow` equivalent and is declined.
+ *
+ * Authored with the declarative {@link pattern} API: `definePattern` auto-applies the compress safety guards — a dynamic or opaque class list
+ * and combinator-subject selectors are excluded (a ref / event handler / dynamic child / dangerous
+ * HTML never blocks a class-only rewrite); the
+ * `rewriteClasses` recipe rebuilds the class StyleMap, declining (`null`) unless both overflow axes
+ * are present, equal, and share an `!important` flag.
+ */
+/** Fold an equal `overflow-x`/`overflow-y` pair into the single `overflow` shorthand. */
+declare const overflowShorthand: AuthoredPattern<Captures>;
+
+/**
+ * @domflax/patterns — compress pattern: `overscroll-behavior-shorthand`.
+ *
+ * Collapses an element whose two overscroll-behavior axes are expressed as separate longhand
+ * declarations and are EQUAL into the single CSS `overscroll-behavior` shorthand:
+ *
+ *   overscroll-behavior-x:contain; overscroll-behavior-y:contain
+ *     ⇒  overscroll-behavior:contain           (Tailwind `overscroll-x-contain overscroll-y-contain` → `overscroll-contain`)
+ *
+ * Tailwind's `overscroll-x-*` / `overscroll-y-*` utilities each resolve to the matching
+ * `overscroll-behavior-{x,y}` axis longhand, and the shared normalizer keeps `overscroll-behavior`
+ * un-expanded (it is NOT one of the box/gap shorthands the normalizer splits). So only the equal-axis
+ * form maps cleanly to a single `overscroll-*` utility. This pass runs the collapse in reverse on the
+ * computed map ONLY when both axes carry the SAME value and `!important` flag, replacing them with one
+ * `overscroll-behavior` decl so the minimizing reverse-emit can pick a single `overscroll-*` token
+ * instead of two axis tokens. When the axes differ it declines, leaving the two longhands verbatim.
+ *
+ * Authored with the declarative {@link pattern} API: `definePattern` auto-applies the compress safety guards — a dynamic or opaque class list
+ * and combinator-subject selectors are excluded (a ref / event handler / dynamic child / dangerous
+ * HTML never blocks a class-only rewrite); the
+ * `rewriteClasses` recipe rebuilds the class StyleMap, declining (`null`) unless both axes are
+ * present, concrete, equal, and share an `!important` flag.
+ */
+/** Fold an equal overscroll-behavior x/y pair into the single `overscroll-behavior` shorthand. */
+declare const overscrollBehaviorShorthand: AuthoredPattern<Captures>;
+
 /**
  * @domflax/patterns — compress pattern: `padding-shorthand`.
  *
@@ -345,8 +685,9 @@ declare const marginShorthand: AuthoredPattern<Captures>;
  * shorthand at parse time). This pass runs the expansion in reverse on the computed map ONLY when
  * the four sides fold cleanly into a 1- or 2-value form — i.e. `top===bottom` AND `left===right`.
  *
- * Authored with the declarative {@link pattern} API: the `where` guards exclude opacity barriers,
- * dynamic class lists, spread/component identity, and combinator subjects; the `rewriteClasses`
+ * Authored with the declarative {@link pattern} API: `definePattern` auto-applies the compress safety guards — a dynamic or opaque class list
+ * and combinator-subject selectors are excluded (a ref / event handler / dynamic child / dangerous
+ * HTML never blocks a class-only rewrite); the `rewriteClasses`
  * recipe rebuilds the class StyleMap, declining (`null`) unless the four sides fold cleanly.
  */
 /**
@@ -354,6 +695,84 @@ declare const marginShorthand: AuthoredPattern<Captures>;
  */
 declare const paddingShorthand: AuthoredPattern<Captures>;
 
+/**
+ * @domflax/patterns — compress pattern: `place-shorthand`.
+ *
+ * Recompacts the grid/flex alignment longhands on an element's computed style into the CSS `place-*`
+ * shorthands whenever the two axes of a pair agree:
+ *
+ *   • align-items   == justify-items     → `place-items: <v>`     (Tailwind `items-* justify-items-*`)
+ *   • align-content == justify-content   → `place-content: <v>`   (Tailwind `content-* justify-*`)
+ *
+ * The two collapses are INDEPENDENT: an element whose items pair agrees but whose content pair does
+ * not collapses only `place-items` and keeps the content longhands verbatim. The shared normalizer
+ * leaves all four alignment properties as independent longhands (it synthesizes no `place-*`
+ * shorthand), so an element styled with two matching axis utilities keeps the longhands until this
+ * pass folds them. When neither pair agrees the pattern declines.
+ *
+ * Authored with the declarative {@link pattern} API: `definePattern` auto-applies the compress safety guards — a dynamic or opaque class list
+ * and combinator-subject selectors are excluded (a ref / event handler / dynamic child / dangerous
+ * HTML never blocks a class-only rewrite); the
+ * `rewriteClasses` recipe rebuilds the class StyleMap, declining (`null`) unless at least one
+ * alignment pair collapses.
+ */
+/** Fold matching align/justify pairs into the `place-items` / `place-content` shorthands. */
+declare const placeShorthand: AuthoredPattern<Captures>;
+
+/**
+ * @domflax/patterns — compress pattern: `scroll-margin-shorthand`.
+ *
+ * Collapses an element whose four scroll-margin sides are expressed as separate longhand
+ * declarations and are ALL EQUAL into the single CSS `scroll-margin` shorthand:
+ *
+ *   scroll-margin-top:1rem; scroll-margin-right:1rem;
+ *   scroll-margin-bottom:1rem; scroll-margin-left:1rem
+ *     ⇒  scroll-margin:1rem                    (Tailwind `scroll-m-4`)
+ *
+ * Tailwind's `scroll-mt-*` / `scroll-mx-*` / … utilities each resolve to the matching
+ * `scroll-margin-*` longhand(s), and the shared normalizer keeps `scroll-margin` un-expanded (it is
+ * NOT one of the box shorthands the normalizer splits). So only the all-equal (1-value) form maps
+ * cleanly to a single `scroll-m-*` utility — the 2-value (`scroll-mx`/`scroll-my`) shape is left to
+ * the resolver's own reverse-emit. This pass runs the collapse in reverse on the computed map ONLY
+ * when all four sides share one value, replacing them with one `scroll-margin` decl so the minimizing
+ * reverse-emit can pick a single `scroll-m-*` token instead of two axis tokens.
+ *
+ * Authored with the declarative {@link pattern} API: `definePattern` auto-applies the compress safety guards — a dynamic or opaque class list
+ * and combinator-subject selectors are excluded (a ref / event handler / dynamic child / dangerous
+ * HTML never blocks a class-only rewrite); the
+ * `rewriteClasses` recipe rebuilds the class StyleMap, declining (`null`) unless the four sides are
+ * present, concrete, equal, and share an `!important` flag.
+ */
+/** Fold four equal scroll-margin sides into the single `scroll-margin` shorthand. */
+declare const scrollMarginShorthand: AuthoredPattern<Captures>;
+
+/**
+ * @domflax/patterns — compress pattern: `scroll-padding-shorthand`.
+ *
+ * Collapses an element whose four scroll-padding sides are expressed as separate longhand
+ * declarations and are ALL EQUAL into the single CSS `scroll-padding` shorthand:
+ *
+ *   scroll-padding-top:1rem; scroll-padding-right:1rem;
+ *   scroll-padding-bottom:1rem; scroll-padding-left:1rem
+ *     ⇒  scroll-padding:1rem                   (Tailwind `scroll-p-4`)
+ *
+ * Tailwind's `scroll-pt-*` / `scroll-px-*` / … utilities each resolve to the matching
+ * `scroll-padding-*` longhand(s), and the shared normalizer keeps `scroll-padding` un-expanded (it is
+ * NOT one of the box shorthands the normalizer splits). So only the all-equal (1-value) form maps
+ * cleanly to a single `scroll-p-*` utility — the 2-value (`scroll-px`/`scroll-py`) shape is left to
+ * the resolver's own reverse-emit. This pass runs the collapse in reverse on the computed map ONLY
+ * when all four sides share one value, replacing them with one `scroll-padding` decl so the minimizing
+ * reverse-emit can pick a single `scroll-p-*` token instead of two axis tokens.
+ *
+ * Authored with the declarative {@link pattern} API: `definePattern` auto-applies the compress safety guards — a dynamic or opaque class list
+ * and combinator-subject selectors are excluded (a ref / event handler / dynamic child / dangerous
+ * HTML never blocks a class-only rewrite); the
+ * `rewriteClasses` recipe rebuilds the class StyleMap, declining (`null`) unless the four sides are
+ * present, concrete, equal, and share an `!important` flag.
+ */
+/** Fold four equal scroll-padding sides into the single `scroll-padding` shorthand. */
+declare const scrollPaddingShorthand: AuthoredPattern<Captures>;
+
 /**
  * @domflax/patterns — compress pattern: `size-shorthand`.
  *
@@ -368,8 +787,9 @@ declare const paddingShorthand: AuthoredPattern<Captures>;
  * at codegen). Both longhands are removed and replaced by the merged `size` decl, so the rewrite is
  * idempotent — once collapsed there is no `width`+`height` pair left to re-match.
  *
- * Authored with the declarative {@link pattern} API: the `where` guards exclude opacity barriers,
- * dynamic class lists, and combinator subjects (compress patterns get NO auto-guards); the
+ * Authored with the declarative {@link pattern} API: `definePattern` auto-applies the compress safety guards — a dynamic or opaque class list
+ * and combinator-subject selectors are excluded (a ref / event handler / dynamic child / dangerous
+ * HTML never blocks a class-only rewrite); the
  * `rewriteClasses` recipe rebuilds the class StyleMap, returning `null` (decline) unless the BASE
  * width/height are equal, concrete, and share an `!important` flag.
  */
@@ -380,8 +800,8 @@ declare const sizeShorthand: AuthoredPattern<Captures>;
  * AUTO-GENERATED by `scripts/gen-registry.mjs` — DO NOT EDIT BY HAND.
  *
  * Regenerate with `npm run generate` (also runs automatically before build/typecheck/test).
- * Patterns are discovered by the `*.pattern.ts` file convention under `src/flatten` and
- * `src/compress`; the array below is sorted flatten-before-compress.
+ * Patterns are discovered by the `*.pattern.ts` file convention under `src/library/flatten`
+ * and `src/library/compress`; the array below is sorted flatten-before-compress.
  */
 
 /** Every built-in pattern, in registration order (flatten patterns before compress). */
@@ -442,8 +862,10 @@ interface Domflax {
     readonly resolver: StyleResolver;
     readonly patterns: readonly Pattern[];
     /**
-     * Transform one file. For `.jsx`/`.tsx` this runs the full pipeline (parse → resolve → flatten →
-     * reverse-emit → print); every other (or unsupported) file is returned unchanged.
+     * Transform one file (SYNCHRONOUS, fully static, never launches a browser). For `.jsx`/`.tsx` this
+     * runs the full pipeline (parse → resolve → flatten[provably-safe only] → reverse-emit → print);
+     * every other (or unsupported) file is returned unchanged. Only provably layout-neutral flattens are
+     * applied — domflax never changes rendering.
      */
     transform(code: string, id: string): DomflaxTransformResult;
 }
@@ -457,6 +879,7 @@ declare function createDomflax(options?: DomflaxOptions): Domflax;
 interface DomflaxVitePlugin {
     readonly name: string;
     readonly enforce: 'pre';
+    /** Vite's per-file source hook. Fully synchronous and browser-free. */
     transform(code: string, id: string): DomflaxTransformResult | null;
 }
 /**
@@ -536,4 +959,4 @@ interface DomflaxDefault {
 /** Default export: an object exposing `vite`, `webpack`, and the programmatic `createDomflax`. */
 declare const domflax: DomflaxDefault;
 
-export { ApplyContext, type ApplyOutcome, ApplyResult, Captures, DEFAULT_FIXPOINT, type Domflax, type DomflaxDefault, type DomflaxOptions, type DomflaxProvider, type DomflaxTransformResult, type DomflaxVitePlugin, type DomflaxWebpackCompiler, type DomflaxWebpackPlugin, EncodedSourceMap, FixpointConfig, IRDocument, Pass, PassManager, Pattern, PhaseRunResult, Pipeline, type ResolvedDomflaxOptions, RewriteFactory, RewriteGroup, RewriteOp, SafetyLevel, SelectorIndex, StyleNormalizer, StyleResolver, SyntheticSink, applyGroups, applyOps, buildSelectorIndex, builtinPatterns, cloneDocument, createDomflax, createNullResolver, createNullSelectorIndex, createPassManager, createPipeline, createRewriteFactory, createSyntheticSink, dedupeClasses, domflax as default, emptyStyleDiv, flexCenterWrapper, insetShorthand, marginShorthand, nestedFlexMerge, paddingShorthand, passthroughWrapper, redundantFragment, runPasses, sizeShorthand, syncClassesFromComputed, vite, webpack };
+export { ApplyContext, type ApplyOutcome, ApplyResult, Captures, DEFAULT_FIXPOINT, Diagnostic, type Domflax, type DomflaxDefault, type DomflaxOptions, type DomflaxProvider, type DomflaxTransformResult, type DomflaxVitePlugin, type DomflaxWebpackCompiler, type DomflaxWebpackPlugin, EncodedSourceMap, FixpointConfig, type FlattenClass, type FlattenClassification, type FlattenVerdict, HaltReason, IRDocument, IRNodeId, MatchContext, PHASE_ORDER, Pass, PassManager, PassPhase, Pattern, type PhaseLoopState, PhaseRunResult, Pipeline, type ResolvedDomflaxOptions, RewriteFactory, RewriteGroup, RewriteOp, RewriteOpDraft, type RunState, SafetyLevel, SelectorIndex, StyleNormalizer, StyleResolver, SyntheticSink, applyGroups, applyOps, borderRadiusShorthand, borderShorthand, buildMatchContext, buildSelectorIndex, builtinPatterns, classifyFlattenOps, cloneDocument, createDomflax, createNullResolver, createNullSelectorIndex, createPassManager, createPipeline, createRewriteFactory, createSyntheticSink, dedupeClasses, domflax as default, displayContentsWrapper, docFingerprint, emptyStyleDiv, evaluateElement, finalizePhase, flattenVerdict, flattenWouldDropStyle, flexCenterWrapper, gapShorthand, inlineFlexCenterWrapper, insetShorthand, marginShorthand, nestedFlexMerge, nestedGridMerge, overflowShorthand, overscrollBehaviorShorthand, paddingShorthand, passthroughWrapper, patternsForPhase, placeShorthand, redundantFragment, redundantInlineWrapper, revertDiagnostic, runPasses, scrollMarginShorthand, scrollPaddingShorthand, sizeShorthand, stampOrigin, syncClassesFromComputed, vite, webpack };