domflax 0.1.0

package/dist/index.d.cts

@@ -0,0 +1,539 @@
+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.cjs';
+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.cjs';
+import { A as AuthoredPattern } from './pattern-P4FIKAUB.cjs';
+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-P4FIKAUB.cjs';
+
+/**
+ * @domflax/core — the pure applier (the one trusted mutator).
+ *
+ * {@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.
+ */
+
+interface ApplyOutcome {
+    /** The new document (the input doc is never mutated). */
+    readonly doc: IRDocument;
+    readonly result: ApplyResult;
+}
+/** Shallow-immutable clone: input doc and its node objects are never mutated. */
+declare function cloneDocument(doc: IRDocument): IRDocument;
+/**
+ * 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
+ * {@link ApplyResult.skipped}) instead of throwing.
+ */
+declare function applyOps(doc: IRDocument, ops: readonly RewriteOp[], ctx?: Partial<ApplyContext>): ApplyOutcome;
+/**
+ * Apply pre-grouped ops (each {@link RewriteGroup} is committed atomically: if ANY op in the group
+ * fails validation, the whole group is skipped and none of its ops mutate the tree).
+ */
+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). */
+declare function createNullSelectorIndex(): SelectorIndex;
+/**
+ * Build a real {@link SelectorIndex} from the active resolver.
+ *
+ * For a resolver that reports project COMPLEX selectors — anything with a combinator (`>`/`+`/`~`/
+ * descendant) or a structural pseudo, i.e. the custom-CSS resolver — every element whose static class
+ * participates in such a selector is flagged so the flatten/compress guards (`targetedByCombinator` /
+ * `affectsSelectorMatching`) fire and a wrapper a selector depends on is NOT flattened. An element is
+ * combinator-coupled when one of its classes is used as a descendant/child ancestor, as a sibling
+ * subject, or as a `:has()` argument; structural-coupled when used in `:nth-child(...)` etc.
+ *
+ * For a combinator-free resolver (Tailwind utilities — no `complexSelectors()`), this degrades to the
+ * null index so behaviour is unchanged.
+ */
+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;
+/**
+ * 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).
+ */
+declare function runPasses(doc: IRDocument, passes: readonly Pass[], ctx: ApplyContext, config?: FixpointConfig): {
+    readonly doc: IRDocument;
+    readonly results: readonly PhaseRunResult[];
+};
+/** A {@link PassManager} that runs the given passes (carried on the manager instance). */
+declare function createPassManager(passes: readonly Pass[]): PassManager;
+
+/**
+ * @domflax/core — the pure, single-file pipeline.
+ *
+ * Wires injected interfaces together: {@link Frontend} → resolve → {@link PassManager} →
+ * {@link Backend}. Core itself stays dependency-free; the resolver, frontend, and backend are all
+ * supplied by the caller, so no heavy third-party libs ever reach this package.
+ */
+
+/** A minimal in-memory {@link SyntheticSink}: dedupes by className, drains in insertion order. */
+declare function createSyntheticSink(): SyntheticSink;
+/** Build the pure single-file {@link Pipeline}. */
+declare function createPipeline(): Pipeline;
+
+/**
+ * @domflax/core — the shared reverse-emit step (computed → className).
+ *
+ * The backend re-prints `className` from each element's {@link ClassList}, but the pass manager
+ * records optimized styles on `computed`. This module folds those optimized computed styles back
+ * into the element's static class tokens, and is the SINGLE source of truth shared by every
+ * orchestrator (the `domflax` meta package, `@domflax/cli`, and the pattern auto-test harness) so
+ * their pipelines cannot diverge.
+ *
+ * ## REPLACE, not append
+ *
+ * For every TOUCHED, rewritable (non-opaque, non-dynamic) element we ask the resolver for the
+ * MINIMAL class set reproducing the element's FULL computed style (`resolver.emit(el.computed)`),
+ * then REPLACE the element's static tokens with it — rather than appending. Replacing is what lets
+ * a compress pass actually shorten output: `px-4 py-4` collapses to `p-4`, equal `w/h` to `size-*`,
+ * the four insets to `inset-0`, and fully-overridden duplicates simply disappear.
+ *
+ * ## Droppability gate (never lose a load-bearing class)
+ *
+ * A token is only removed when `resolver.selectorUsage(token).droppable` is true — i.e. it is a
+ * plain, resolver-owned utility whose entire contribution is reproducible from `computed`. Tokens
+ * that are unknown to the resolver, opaque (combinator/at-rule utilities whose effect never folds
+ * onto the element's own box), variant-bound, or referenced by a custom-CSS selector are NOT
+ * droppable and are preserved verbatim. As a safety net, if `emit` produces nothing at all we leave
+ * the element's tokens untouched (a resolver that failed to load must never erase classes).
+ */
+
+/**
+ * Fold every TOUCHED, rewritable element's optimized computed style back into the MINIMAL static
+ * class-token set (see module docs). Mutates `doc` in place.
+ */
+declare function syncClassesFromComputed(doc: IRDocument, resolver: StyleResolver, norm: StyleNormalizer): void;
+
+/**
+ * @domflax/patterns — flatten pattern: `empty-style-div`.
+ *
+ * Collapses the most common piece of structural noise of all: a `<div>` whose ONLY role is to wrap
+ * a single child while contributing nothing to layout or paint —
+ *
+ *   <div><Child/></div>            (no styles at all)
+ *   <div style="display:block"><Child/></div>   (the default; still a no-op box)
+ *
+ * Such a div is layout-neutral: it is a plain block box with no own visual style, establishes no
+ * box / formatting / stacking context, is not a containing block, and declares no custom properties
+ * 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).
+ */
+/**
+ * Flatten a layout-neutral, style-free `<div>` wrapper into its sole element child.
+ */
+declare const emptyStyleDiv: AuthoredPattern<Captures>;
+
+/**
+ * @domflax/patterns — flatten pattern: `flex-center-wrapper`.
+ *
+ * Collapses the ubiquitous "centering wrapper" idiom
+ *
+ *   <div style="display: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`.
+ * 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.
+ */
+/**
+ * Flatten a flex-centering `<div>` wrapper into its sole element child, granting the child
+ * `place-self:center`.
+ */
+declare const flexCenterWrapper: AuthoredPattern<Captures>;
+
+/**
+ * @domflax/patterns — flatten pattern: `nested-flex-merge`.
+ *
+ * Collapses a redundant nesting of two flex containers
+ *
+ *   <div style="display:flex; align-items:center; gap:8px">
+ *     <div style="display:flex; flex-direction:column"> … </div>
+ *   </div>
+ *
+ * where the OUTER flex container's sole element child is ITSELF a flex container, into a single
+ * flex container that carries the union of both elements' flex declarations. The outer wrapper's
+ * box is then structural noise (it paints nothing and only establishes a flex context that the
+ * merged child now also establishes), so it is removed.
+ *
+ * Authored with the declarative {@link pattern} API: the match is a flex `<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) flex container, the wrapper must carry only transferable flex/inheritable
+ * declarations, and the two must not conflict on any shared flex property — lives in the `rewrite`
+ * op-draft factory escape hatch, which folds inherited styles, transfers the wrapper's flex
+ * declarations onto the child (target-wins), then unwraps the wrapper.
+ */
+/**
+ * Flatten a flex container whose sole child is a compatible flex container into a single container.
+ */
+declare const nestedFlexMerge: AuthoredPattern<Captures>;
+
+/**
+ * @domflax/patterns — flatten pattern: `passthrough-wrapper`.
+ *
+ * Collapses a purely-structural wrapper that exists for no reason at all:
+ *
+ *   <div><Child/></div>
+ *
+ * The wrapper paints nothing, establishes no box / formatting / stacking context, carries no
+ * attributes beyond an (optional) inert class, holds exactly one element child, and is free of every
+ * opacity barrier (ref / event-handlers / dynamic children / dangerous html / spread / component).
+ * 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).
+ */
+/**
+ * Flatten a do-nothing `<div>` wrapper into its sole element child, folding any inheritable styles
+ * down first so inherited values survive the box removal.
+ */
+declare const passthroughWrapper: AuthoredPattern<Captures>;
+
+/**
+ * @domflax/patterns — flatten pattern: `redundant-fragment`.
+ *
+ * Collapses a fragment that wraps exactly one child
+ *
+ *   <><Child/></>            →   <Child/>
+ *
+ * A fragment renders no box of its own, so a fragment whose sole purpose is to wrap a single node
+ * is pure structural noise: splicing the child up into the fragment's slot is invisible in both
+ * the rendered DOM and the project's CSS cascade.
+ *
+ * Anchoring: the pass manager only visits ELEMENT nodes (see core's `elementIds`), never fragments,
+ * so this pattern is anchored on the fragment's sole *element* child and removes the PARENT fragment.
+ * Because the match is PARENT-anchored (and reads a fragment's `meta`, which the element-only
+ * combinator vocabulary cannot inspect), it uses the declarative API's two escape hatches: a raw
+ * `match` predicate and a raw `rewrite` op-draft factory.
+ */
+/**
+ * Flatten a fragment that wraps exactly one child into that child.
+ *
+ * Safety level 1 (`safe`): a purely structural, style-free, selector-transparent cleanup.
+ */
+declare const redundantFragment: AuthoredPattern<Captures>;
+
+/**
+ * @domflax/patterns — compress pattern: `dedupe-classes`.
+ *
+ * Removes duplicate / fully-overridden class tokens that resolve to the same property where a
+ * LATER token wins, leaving the minimal set of tokens with an IDENTICAL computed style. The
+ * canonical case:
+ *
+ *   <p class="text-sm text-lg">…</p>   →   <p class="text-lg">…</p>
+ *
+ * Both `text-sm` and `text-lg` set `font-size`; resolution already made `text-lg` win, so the
+ * computed `font-size` is `text-lg`'s value and `text-sm` contributes NOTHING to the final
+ * computed style. The earlier token is pure noise and can be dropped without changing a pixel.
+ *
+ * How redundancy is detected (purely from the already-resolved, normalized computed StyleMap):
+ *   • every declaration carries provenance — `origin` (the winning token) and `shadowed`
+ *     (the tokens it overrode);
+ *   • a class token is FULLY OVERRIDDEN iff it appears in some declaration's `shadowed` list but
+ *     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
+ * fully-overridden, resolver-droppable tokens to delete (their `shadowed` provenance is pruned
+ * automatically before the minimal class StyleMap is re-installed).
+ */
+/**
+ * Collapse a class list to the minimal token set that yields an identical computed style, by
+ * dropping tokens whose declarations are fully overridden by later tokens.
+ */
+declare const dedupeClasses: AuthoredPattern<Captures>;
+
+/**
+ * @domflax/patterns — compress pattern: `inset-shorthand`.
+ *
+ * Recompacts the four physical inset longhands (`top`/`right`/`bottom`/`left`) on an element's
+ * computed style back into the tightest CSS shorthand the values allow:
+ *
+ *   • all four equal                       → `inset: <v>`
+ *   • top == bottom  (a matching pair)     → `inset-block: <v>`   (Tailwind `inset-y-*`)
+ *   • left == right  (a matching pair)     → `inset-inline: <v>`  (Tailwind `inset-x-*`)
+ *
+ * The two axis collapses are independent: an element whose `top == bottom` but `left != right`
+ * 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
+ * StyleMap, declining (`null`) unless at least one inset axis collapses.
+ */
+/**
+ * Collapse equal/paired physical inset longhands into the `inset` / `inset-block` / `inset-inline`
+ * shorthands on an element's computed style.
+ */
+declare const insetShorthand: AuthoredPattern<Captures>;
+
+/**
+ * @domflax/patterns — compress pattern: `margin-shorthand`.
+ *
+ * Collapses the four explicit margin longhands
+ *
+ *   margin-top / margin-right / margin-bottom / margin-left
+ *
+ * back into a single CSS `margin` shorthand declaration on the SAME element (the margin analogue of
+ * `padding-shorthand`, covering the `m` / `mx` / `my` collapse), choosing the shortest legal
+ * 1–4-value form:
+ *
+ *   • all four equal               → `margin: <v>`           (the `m` case)
+ *   • top==bottom and left==right  → `margin: <y> <x>`       (the `my`/`mx` case)
+ *   • left==right (top!=bottom)    → `margin: <t> <x> <b>`
+ *   • otherwise                    → `margin: <t> <r> <b> <l>`
+ *
+ * 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
+ * StyleMap, declining (`null`) unless all four margin longhands are present with a uniform
+ * (non-)`!important` flag.
+ */
+/**
+ * Fold four margin longhands into one `margin` shorthand on the element's base style block.
+ */
+declare const marginShorthand: AuthoredPattern<Captures>;
+
+/**
+ * @domflax/patterns — compress pattern: `padding-shorthand`.
+ *
+ * Collapses an element whose four padding sides are expressed as separate longhand declarations
+ * back into the shortest equivalent shorthand:
+ *
+ *   padding-top:16px; padding-right:16px; padding-bottom:16px; padding-left:16px
+ *     ⇒  padding:16px                         (Tailwind `p-4`)
+ *
+ *   padding-top:8px; padding-bottom:8px; padding-left:16px; padding-right:16px
+ *     ⇒  padding:8px 16px                     (Tailwind `px-4 py-2`)
+ *
+ * The IR's computed StyleMap is canonically LONGHAND (the shared normalizer expands every box
+ * 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`
+ * recipe rebuilds the class StyleMap, declining (`null`) unless the four sides fold cleanly.
+ */
+/**
+ * Compress an element's four equal/paired padding longhands into the shortest `padding` shorthand.
+ */
+declare const paddingShorthand: AuthoredPattern<Captures>;
+
+/**
+ * @domflax/patterns — compress pattern: `size-shorthand`.
+ *
+ * Collapses an element whose computed `width` and `height` are EQUAL into the single Tailwind
+ * `size-*` utility:
+ *
+ *   <div style="width:1rem; height:1rem"/>   →   <div class="size-4"/>
+ *
+ * At the IR level we work over the normalized computed StyleMap (CSS longhands), so the pattern
+ * recognizes the `width === height` shape in the BASE condition and rebuilds the element's class
+ * StyleMap with a single `size` declaration (the resolver reverse-emits the concrete `size-*` token
+ * 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
+ * `rewriteClasses` recipe rebuilds the class StyleMap, returning `null` (decline) unless the BASE
+ * width/height are equal, concrete, and share an `!important` flag.
+ */
+/** Fold equal `width`/`height` into the `size-*` utility. */
+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.
+ */
+
+/** Every built-in pattern, in registration order (flatten patterns before compress). */
+declare const builtinPatterns: readonly Pattern[];
+
+/**
+ * domflax — public meta package.
+ *
+ * Re-exports the entire `@domflax/core` public API (types + reference runtime) and the built-in
+ * `@domflax/patterns` library, then layers thin, framework-agnostic build adapters on top
+ * (`vite()` / `webpack()`) plus a programmatic `createDomflax()` factory.
+ *
+ * Each adapter runs the SAME single-file engine as {@link createDomflax} (JSX/TSX frontend + lazy
+ * Tailwind/CSS resolver → core pass manager → reverse-emit → JSX backend). The adapters are
+ * structurally typed against their bundlers — they never hard-depend on `vite` or `webpack`.
+ *
+ * Future deps (intentionally NOT imported yet — they land in a later stage):
+ *   - `@domflax/frontend-html` — HTML / Astro-static frontend feeding the pipeline.
+ *   - `@domflax/backend-*`     — additional surgical codegen backends.
+ */
+
+/** How class names resolve to computed styles. */
+type DomflaxProvider = 'auto' | 'tailwind' | 'custom';
+/** Public adapter/factory options (mirrors the documented `domflax({...})` surface). */
+interface DomflaxOptions {
+    /** Resolution strategy. Defaults to `'auto'`. */
+    readonly provider?: DomflaxProvider;
+    /** Stylesheets to parse when `provider` is `'custom'`. */
+    readonly cssFiles?: readonly string[];
+    /** Preview changes without rewriting source. */
+    readonly dryRun?: boolean;
+    /** Optimization aggressiveness handed to the pass manager (0 lint … 3 aggressive). */
+    readonly safety?: SafetyLevel;
+    /** File globs/extensions the adapters should consider. Defaults to jsx/tsx/html. */
+    readonly include?: readonly string[];
+}
+/** Fully-resolved options with defaults applied. */
+interface ResolvedDomflaxOptions {
+    readonly provider: DomflaxProvider;
+    readonly cssFiles: readonly string[];
+    readonly dryRun: boolean;
+    readonly safety: SafetyLevel;
+    readonly include: readonly string[];
+}
+/** Result of a single-file transform. `map` is null until codegen lands. */
+interface DomflaxTransformResult {
+    readonly code: string;
+    readonly map: EncodedSourceMap | null;
+}
+/**
+ * A configured domflax engine. Holds the wired core {@link Pipeline}, the passthrough
+ * {@link StyleResolver}, and the built-in {@link Pattern} set, and exposes a single-file
+ * `transform`.
+ */
+interface Domflax {
+    readonly options: ResolvedDomflaxOptions;
+    readonly pipeline: Pipeline;
+    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(code: string, id: string): DomflaxTransformResult;
+}
+declare function createDomflax(options?: DomflaxOptions): Domflax;
+/**
+ * Minimal Vite-plugin shape. Declared locally so this adapter does NOT depend on `vite`'s types
+ * (an optional, type-only peer). Structurally compatible with Vite's `Plugin` for the hooks domflax
+ * uses: `enforce: 'pre'` runs domflax before Vite's JSX→`createElement` transform, and `transform`
+ * is Vite's per-file source hook. Returning `null` is Vite's "no change" signal.
+ */
+interface DomflaxVitePlugin {
+    readonly name: string;
+    readonly enforce: 'pre';
+    transform(code: string, id: string): DomflaxTransformResult | null;
+}
+/**
+ * Vite adapter. Returns a real Vite `Plugin` (`enforce: 'pre'`) whose `transform` runs the domflax
+ * engine on `.jsx`/`.tsx` modules — strips any bundler query suffix (e.g. `App.tsx?used`) before
+ * matching, returns `{ code, map }` when the source changed, and `null` (Vite's unchanged signal)
+ * for unchanged sources and for any non-jsx/tsx module.
+ *
+ * @example
+ * ```js
+ * // vite.config.js
+ * import domflax from 'domflax';
+ * export default { plugins: [domflax.vite({ provider: 'tailwind' })] };
+ * ```
+ */
+declare function vite(options?: DomflaxOptions): DomflaxVitePlugin;
+/** Anything carrying a `module.rules` array — both a webpack `Compiler.options` and Next's bare config. */
+interface DomflaxWebpackModuleHost {
+    module?: {
+        rules?: unknown[];
+    };
+}
+/**
+ * Minimal webpack-compiler shape. Declared locally so this adapter does NOT depend on `webpack`'s
+ * types. domflax only needs to push a rule onto the host's `module.rules`.
+ *
+ * `apply` accepts BOTH shapes: a real webpack `Compiler` (rules live under `compiler.options.module`)
+ * AND the bare `config` object Next.js hands you from `webpack(config)` (rules live directly under
+ * `config.module`). It duck-types `compiler.options ?? compiler` to find the right host.
+ */
+interface DomflaxWebpackCompiler extends DomflaxWebpackModuleHost {
+    options?: DomflaxWebpackModuleHost;
+}
+/**
+ * Minimal webpack-plugin shape. `apply(compiler)` is the webpack plugin entry point.
+ */
+interface DomflaxWebpackPlugin {
+    readonly name: string;
+    apply(compiler: DomflaxWebpackCompiler): void;
+}
+/**
+ * webpack adapter (also the Next.js path). Returns a plugin whose `apply(compiler)` injects a
+ * pre-enforced `module.rule` that invokes the domflax {@link ./webpack-loader loader} on every
+ * `.jsx`/`.tsx` module. The loader runs the SAME lazy engine as {@link createDomflax} (no eager
+ * Tailwind/postcss load).
+ *
+ * Next.js wiring (`next.config.js`) — Next exposes the underlying webpack config via `webpack(config)`:
+ * ```js
+ * // next.config.js
+ * const domflax = require('domflax');
+ * module.exports = {
+ *   webpack(config) {
+ *     domflax.webpack({ provider: 'tailwind' }).apply(config);
+ *     return config;
+ *   },
+ * };
+ * ```
+ * `apply(compiler)` is intentionally duck-typed on `compiler.options.module.rules`, so it accepts
+ * both a real webpack `Compiler` and the bare `config` object Next.js hands you.
+ *
+ * Caveat: this targets the webpack builder only. **Turbopack is not yet supported** — it does not
+ * accept arbitrary webpack loaders, so the `next.config.js` wiring above is a no-op under
+ * `next dev --turbopack`. Run domflax through the webpack builder until Turbopack exposes a loader API.
+ */
+declare function webpack(options?: DomflaxOptions): DomflaxWebpackPlugin;
+/**
+ * The default-export namespace. Exposes the build adapters and the programmatic factory as an OBJECT
+ * so the documented `import domflax from 'domflax'; domflax.vite()` / `domflax.webpack()` works (and a
+ * CommonJS `const domflax = require('domflax'); domflax.vite()` too). The named exports
+ * (`createDomflax`, `vite`, `webpack`, …) remain available for direct import.
+ */
+interface DomflaxDefault {
+    createDomflax(options?: DomflaxOptions): Domflax;
+    vite(options?: DomflaxOptions): DomflaxVitePlugin;
+    webpack(options?: DomflaxOptions): DomflaxWebpackPlugin;
+}
+/** 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 };