domflax 0.1.0

package/dist/types-BQ7l6dVe.d.cts

@@ -0,0 +1,749 @@
+/**
+ * @domflax/core — public type contract (packages/core/src/types.ts)
+ *
+ * SINGLE SOURCE OF TRUTH for the whole monorepo. Pure type/interface declarations
+ * only: ZERO runtime. Every downstream package imports these exact names.
+ *
+ * Compiles under: strict, verbatimModuleSyntax, isolatedDeclarations, erasableSyntaxOnly,
+ * isolatedModules. No `const enum` (TS6 erasableSyntaxOnly): every closed set is a
+ * string/number literal UNION here; the matching frozen `as const` runtime objects live in
+ * sibling runtime modules (constants.ts), not in this file.
+ */
+type Brand<T, B extends string> = T & {
+    readonly __brand: B;
+};
+/** Distributive Omit that preserves discriminated-union narrowing. */
+type DistributiveOmit<T, K extends keyof T> = T extends unknown ? Omit<T, K> : never;
+/**
+ * Deep-immutable view. The pass manager hands patterns a DeepReadonly<IRElement>/
+ * DeepReadonly<IRDocument> so invariant #4 ("rule authors can never mutate the IR") is a
+ * COMPILE-TIME guarantee, not a convention (review-2 blocker). In dev the runtime additionally
+ * wraps these in a throw-on-write Proxy.
+ */
+type DeepReadonly<T> = T extends (...args: never[]) => unknown ? T : T extends ReadonlyMap<infer K, infer V> ? ReadonlyMap<DeepReadonly<K>, DeepReadonly<V>> : T extends ReadonlySet<infer U> ? ReadonlySet<DeepReadonly<U>> : T extends Map<infer K, infer V> ? ReadonlyMap<DeepReadonly<K>, DeepReadonly<V>> : T extends Set<infer U> ? ReadonlySet<DeepReadonly<U>> : T extends readonly (infer U)[] ? readonly DeepReadonly<U>[] : T extends object ? {
+    readonly [K in keyof T]: DeepReadonly<T[K]>;
+} : T;
+type IRNodeId = Brand<number, 'IRNodeId'>;
+type SourceFileId = Brand<number, 'SourceFileId'>;
+type ExprRef = Brand<number, 'ExprRef'>;
+type PatternName = string;
+interface IdAllocator {
+    next(): IRNodeId;
+    /** Peek the next id without consuming, for deterministic dry-run validation. */
+    readonly peek: IRNodeId;
+}
+/** SAFETY: 0 lint · 1 safe · 2 default · 3 aggressive. (Runtime `SAFETY` object lives in constants.ts.) */
+type SafetyLevel = 0 | 1 | 2 | 3;
+interface Position {
+    readonly line: number;
+    readonly column: number;
+}
+interface SourceSpan {
+    readonly file: SourceFileId;
+    readonly start: number;
+    readonly end: number;
+    readonly startLoc?: Position;
+    readonly endLoc?: Position;
+}
+type FileKind = 'jsx' | 'tsx' | 'html' | 'unknown';
+type FrontendKind = 'jsx' | 'html';
+interface SourceFile {
+    readonly id: SourceFileId;
+    readonly path: string;
+    readonly text: string;
+    readonly frontend: FrontendKind;
+    readonly eol: '\n' | '\r\n';
+    readonly indentUnit: string;
+    native?: unknown;
+}
+type CssProperty = Brand<string, 'CssProperty'>;
+type CssValue = Brand<string, 'CssValue'>;
+type ConditionKey = Brand<string, 'ConditionKey'>;
+type DeclSignature = Brand<string, 'DeclSignature'>;
+interface StyleCondition {
+    readonly media: string;
+    readonly states: readonly string[];
+    readonly pseudoElement: string;
+}
+type StyleOrigin = {
+    readonly kind: 'class';
+    readonly tokenIndex: number;
+    readonly className: string;
+} | {
+    readonly kind: 'inline';
+} | {
+    readonly kind: 'inherited';
+    readonly from: IRNodeId;
+} | {
+    readonly kind: 'synthetic';
+};
+/**
+ * `relativeToParent` is set when the value uses a parent-relative unit (em/ex/ch/%/lh, or
+ * font-relative line-height). The applier REFUSES to fold such a declaration onto a child whose
+ * font-size/inline reference differs (review-1 major: relative-unit fold). Computed by the
+ * normalizer at parse time (purely syntactic detection — no value resolution).
+ */
+interface StyleDecl {
+    readonly property: CssProperty;
+    readonly value: CssValue;
+    readonly important: boolean;
+    readonly relativeToParent: boolean;
+    readonly inherited: boolean;
+    readonly origin?: StyleOrigin;
+    readonly shadowed?: readonly StyleOrigin[];
+}
+interface StyleBlock {
+    readonly condition: StyleCondition;
+    readonly decls: ReadonlyMap<CssProperty, StyleDecl>;
+}
+interface StyleMap {
+    readonly blocks: ReadonlyMap<ConditionKey, StyleBlock>;
+}
+/**
+ * Canonical, versioned set of inherited CSS properties (review-1 major: fold allowlist
+ * completeness). The SINGLE source consumed by foldInheritedStyles, hasOwnVisualStyle reasoning,
+ * and the verifier. Includes author custom properties via the `--` predicate handled in runtime.
+ */
+interface InheritedPropertyTable {
+    readonly version: string;
+    readonly properties: ReadonlySet<CssProperty>;
+    isInherited(property: CssProperty): boolean;
+}
+/**
+ * Syntactic-only normalizer (shorthand expansion, color/unit canonicalization, ordering).
+ * NEVER resolves initial/inherited/computed defaults — that is the verifier's job. The SAME
+ * instance/version is shared by resolver + patterns + verifier (correctness lynchpin).
+ */
+interface StyleNormalizer {
+    readonly version: string;
+    normalizeDeclaration(prop: string, value: string, important: boolean): readonly StyleDecl[];
+    normalizeValue(prop: CssProperty, raw: string): CssValue;
+    normalizeStyleMap(sm: StyleMap): StyleMap;
+    equals(a: StyleMap, b: StyleMap): boolean;
+    readonly inherited: InheritedPropertyTable;
+}
+interface NodeMeta {
+    hasRef: boolean;
+    hasEventHandlers: boolean;
+    hasKey: boolean;
+    hasSpreadAttrs: boolean;
+    hasDynamicChildren: boolean;
+    isComponent: boolean;
+    hasDangerousHtml: boolean;
+    targetedByCombinator: boolean;
+    targetedByStructuralPseudo: boolean;
+    selectorDependents: number;
+    hasOwnVisualStyle: boolean;
+    establishesBox: boolean;
+    establishesStackingContext: boolean;
+    isContainingBlock: boolean;
+    establishesFormattingContext: boolean;
+    declaresCustomProperties: boolean;
+    whitespaceSensitive: boolean;
+    touched: boolean;
+    synthetic: boolean;
+    safetyFloor: SafetyLevel;
+}
+interface ClassToken {
+    readonly value: string;
+    readonly span?: SourceSpan;
+}
+type ClassSegment = {
+    readonly kind: 'static';
+    readonly span?: SourceSpan;
+    readonly tokens: readonly ClassToken[];
+} | {
+    readonly kind: 'dynamic';
+    readonly span?: SourceSpan;
+    readonly expr: ExprRef;
+};
+type ClassListForm = 'string-literal' | 'template-literal' | 'call' | 'conditional' | 'member' | 'absent';
+interface ClassList {
+    readonly form: ClassListForm;
+    readonly segments: readonly ClassSegment[];
+    readonly valueSpan: SourceSpan | null;
+    readonly attrSpan?: SourceSpan;
+    readonly hasDynamic: boolean;
+    readonly opaque: boolean;
+    readonly rewritable: boolean;
+}
+type AttrValue = {
+    readonly kind: 'static';
+    readonly value: string | boolean;
+    readonly span?: SourceSpan;
+} | {
+    readonly kind: 'dynamic';
+    readonly expr: ExprRef;
+    readonly span?: SourceSpan;
+};
+interface AttrMap {
+    readonly entries: ReadonlyMap<string, AttrValue>;
+    readonly spreads: readonly ExprRef[];
+    readonly order: readonly string[];
+}
+interface InlineStyle {
+    readonly decls: ReadonlyMap<CssProperty, StyleDecl>;
+    readonly dynamic: readonly ExprRef[] | null;
+    readonly span?: SourceSpan;
+}
+type IRNodeKind = 'element' | 'text' | 'expr' | 'fragment' | 'comment';
+type IRNamespace = 'html' | 'svg' | 'mathml' | 'component';
+interface IRNodeBase {
+    readonly id: IRNodeId;
+    readonly kind: IRNodeKind;
+    parent: IRNodeId | null;
+    span: SourceSpan | null;
+    meta: NodeMeta;
+}
+interface IRElement extends IRNodeBase {
+    readonly kind: 'element';
+    tag: string;
+    namespace: IRNamespace;
+    isComponent: boolean;
+    selfClosing: boolean;
+    classes: ClassList;
+    inlineStyle: InlineStyle;
+    computed: StyleMap;
+    attrs: AttrMap;
+    children: IRNodeId[];
+}
+interface IRText extends IRNodeBase {
+    readonly kind: 'text';
+    value: string;
+    collapsible: boolean;
+}
+interface IRExpr extends IRNodeBase {
+    readonly kind: 'expr';
+    expr: ExprRef;
+}
+interface IRFragment extends IRNodeBase {
+    readonly kind: 'fragment';
+    children: IRNodeId[];
+}
+interface IRComment extends IRNodeBase {
+    readonly kind: 'comment';
+    value: string;
+}
+type IRNode = IRElement | IRText | IRExpr | IRFragment | IRComment;
+type ExprKind = 'call' | 'member' | 'conditional' | 'template' | 'identifier' | 'spread' | 'other';
+interface ExprRecord {
+    readonly ref: ExprRef;
+    readonly span: SourceSpan;
+    readonly kind: ExprKind;
+    payload?: unknown;
+}
+interface ExprRegistry {
+    get(r: ExprRef): ExprRecord | undefined;
+    intern(rec: Omit<ExprRecord, 'ref'>): ExprRef;
+    releasePayloads(): void;
+}
+interface Backref {
+    readonly nodeId: IRNodeId;
+    readonly span: SourceSpan;
+    readonly openTagSpan: SourceSpan | null;
+    readonly closeTagSpan: SourceSpan | null;
+    readonly innerSpan: SourceSpan | null;
+    readonly selfClosing: boolean;
+}
+interface BackrefTable {
+    get(id: IRNodeId): Backref | undefined;
+    span(id: IRNodeId): SourceSpan | null;
+    childrenSpan(id: IRNodeId): SourceSpan | null;
+}
+/** ONE document type (D9): absorbs IRModule / SourceModule. */
+interface IRDocument {
+    root: IRNodeId;
+    nodes: Map<IRNodeId, IRNode>;
+    exprs: ExprRegistry;
+    sources: Map<SourceFileId, SourceFile>;
+    backref: BackrefTable;
+    frontend: FrontendKind;
+    alloc: IdAllocator;
+}
+type VisitSignal = void | 'skip' | 'stop';
+interface VisitContext {
+    readonly doc: DeepReadonly<IRDocument>;
+    readonly depth: number;
+    parent(): IRNode | null;
+}
+interface Visitor {
+    enter?(n: IRNode, c: VisitContext): VisitSignal;
+    exit?(n: IRNode, c: VisitContext): VisitSignal;
+}
+interface ElementSpec {
+    readonly kind: 'element';
+    readonly tag: string;
+    readonly namespace?: IRNamespace;
+    readonly classes?: StyleMap;
+    readonly attrs?: ReadonlyMap<string, string | boolean>;
+    readonly children?: readonly NodeSpec[];
+    readonly selfClosing?: boolean;
+}
+interface TextSpec {
+    readonly kind: 'text';
+    readonly value: string;
+}
+interface ExprSpec {
+    readonly kind: 'expr';
+    readonly expr: ExprRef;
+}
+interface FragmentSpec {
+    readonly kind: 'fragment';
+    readonly children: readonly NodeSpec[];
+}
+interface CommentSpec {
+    readonly kind: 'comment';
+    readonly value: string;
+}
+/** Reuse an existing live node (preserves its IRNodeId — D10). */
+interface NodeRefSpec {
+    readonly kind: 'ref';
+    readonly ref: IRNodeId;
+}
+type NodeSpec = ElementSpec | TextSpec | ExprSpec | FragmentSpec | CommentSpec | NodeRefSpec;
+type Severity = 'error' | 'warn' | 'info' | 'debug';
+type DiagnosticCode = 'DF_PATTERN_THREW' | 'DF_OP_PRECONDITION_FAILED' | 'DF_CROSSED_DYNAMIC_BOUNDARY' | 'DF_SAFETY_CEILING_EXCEEDED' | 'DF_STYLE_CONFLICT_UNRESOLVED' | 'DF_FIXPOINT_BUDGET' | 'DF_FIXPOINT_OSCILLATION' | 'DF_NON_INHERITABLE_FOLD' | 'DF_RELATIVE_UNIT_FOLD' | 'DF_CUSTOM_PROP_COUPLING' | 'DF_STRUCTURAL_PSEUDO_TARGET' | 'DF_SELECTOR_MEMBERSHIP' | 'DF_NODE_REMOVED' | 'DF_PATTERN_APPLIED' | 'DF_VERIFY_REVERTED' | 'DF_VERIFY_INCONCLUSIVE';
+interface Diagnostic {
+    readonly code: DiagnosticCode;
+    readonly severity: Severity;
+    readonly message: string;
+    readonly span?: SourceSpan;
+    readonly nodeId?: IRNodeId;
+    readonly pattern?: PatternName;
+    readonly phase?: PassPhase;
+    readonly iteration?: number;
+    readonly data?: Readonly<Record<string, unknown>>;
+    readonly cause?: unknown;
+}
+interface PassTraceEntry {
+    readonly phase: PassPhase;
+    readonly iteration: number;
+    readonly pattern: PatternName;
+    readonly nodeId: IRNodeId;
+    readonly opCount: number;
+}
+interface Reporter {
+    report(d: Diagnostic): void;
+    trace?(e: PassTraceEntry): void;
+}
+type OpaqueReason = 'combinator-variant' | 'container-query' | 'tw-var-coupling' | 'author-var-coupling' | 'descendant-selector' | 'structural-pseudo' | 'compound-membership' | 'dynamic-at-rule' | 'unsupported-unit' | 'arbitrary-property';
+interface OpaqueToken {
+    readonly token: string;
+    readonly reason: OpaqueReason;
+    readonly detail?: string;
+}
+interface ResolverDiagnostic {
+    readonly severity: Severity;
+    readonly message: string;
+    readonly token?: string;
+}
+interface ResolveInput {
+    readonly classes: readonly string[];
+    readonly inlineStyle?: string;
+    readonly element?: {
+        readonly tagName: string;
+        readonly namespace?: 'html' | 'svg';
+    };
+}
+interface ResolveResult {
+    readonly styles: StyleMap;
+    readonly resolved: readonly string[];
+    readonly unknown: readonly string[];
+    readonly opaque: readonly OpaqueToken[];
+    readonly warnings: readonly ResolverDiagnostic[];
+}
+/** How a class participates in project selectors — drives compress safety (review-1). */
+interface SelectorUsage {
+    readonly asSubject: boolean;
+    readonly asAncestor: boolean;
+    readonly asCompound: boolean;
+    readonly asSibling: boolean;
+    readonly asHasArgument: boolean;
+    readonly asStructural: boolean;
+    /** True iff the class is referenced ONLY as a plain subject — i.e. safe to drop/rename. */
+    readonly droppable: boolean;
+}
+interface SyntheticClass {
+    readonly className: string;
+    readonly decls: StyleMap;
+    readonly css: string;
+}
+interface EmitContext {
+    readonly normalizer: StyleNormalizer;
+    readonly sink: SyntheticSink;
+    readonly preserveTokens?: readonly string[];
+    readonly budgetMs?: number;
+}
+interface SyntheticSink {
+    register(s: SyntheticClass): string;
+    drain(): readonly SyntheticClass[];
+}
+interface EmitResult {
+    readonly classes: readonly string[];
+    readonly residual?: SyntheticClass;
+    readonly exact: boolean;
+    readonly warnings: readonly ResolverDiagnostic[];
+}
+interface StyleResolver {
+    readonly id: string;
+    readonly provider: string;
+    readonly fingerprint: string;
+    owns(token: string): boolean;
+    resolve(input: ResolveInput): ResolveResult;
+    emit(styles: StyleMap, ctx: EmitContext): EmitResult;
+    /** Reports every project selector referencing a class — compress safety (review-1 major). */
+    selectorUsage(token: string): SelectorUsage;
+}
+interface SelectorIndex {
+    targetedByCombinator(id: IRNodeId): boolean;
+    targetedByStructuralPseudo(id: IRNodeId): boolean;
+    /**
+     * Set of node ids whose combinator / structural-pseudo match-set would CHANGE if `id` were
+     * unwrapped/removed (self, child, and former siblings). Empty ⇒ structurally safe.
+     * (review-1 blocker: guard the child & siblings, not just the wrapper.)
+     */
+    reparentImpact(id: IRNodeId): ReadonlySet<IRNodeId>;
+}
+interface OpOrigin {
+    readonly pattern: PatternName;
+    readonly category: PassCategory;
+    readonly safety: SafetyLevel;
+}
+type StyleConflictPolicy = 'target-wins' | 'source-wins' | 'abort';
+type RewriteOp = {
+    readonly op: 'removeNode';
+    readonly target: IRNodeId;
+    readonly origin: OpOrigin;
+} | {
+    readonly op: 'unwrap';
+    readonly target: IRNodeId;
+    readonly origin: OpOrigin;
+} | {
+    readonly op: 'replaceWith';
+    readonly target: IRNodeId;
+    readonly replacement: NodeSpec;
+    readonly origin: OpOrigin;
+} | {
+    readonly op: 'wrap';
+    readonly target: IRNodeId;
+    readonly wrapper: ElementSpec;
+    readonly origin: OpOrigin;
+} | {
+    readonly op: 'insertBefore';
+    readonly anchor: IRNodeId;
+    readonly node: NodeSpec;
+    readonly origin: OpOrigin;
+} | {
+    readonly op: 'insertAfter';
+    readonly anchor: IRNodeId;
+    readonly node: NodeSpec;
+    readonly origin: OpOrigin;
+} | {
+    readonly op: 'moveNode';
+    readonly target: IRNodeId;
+    readonly newParent: IRNodeId;
+    readonly index: number;
+    readonly origin: OpOrigin;
+} | {
+    readonly op: 'mergeSiblings';
+    readonly first: IRNodeId;
+    readonly second: IRNodeId;
+    readonly origin: OpOrigin;
+} | {
+    readonly op: 'setClassList';
+    readonly target: IRNodeId;
+    readonly style: StyleMap;
+    readonly preserveOpaque: boolean;
+    readonly origin: OpOrigin;
+} | {
+    readonly op: 'mergeStyle';
+    readonly target: IRNodeId;
+    readonly source: IRNodeId | null;
+    readonly style: StyleMap;
+    readonly onConflict: StyleConflictPolicy;
+    readonly origin: OpOrigin;
+} | {
+    readonly op: 'foldInheritedStyles';
+    readonly from: IRNodeId;
+    readonly into: readonly IRNodeId[];
+    readonly properties: readonly CssProperty[] | 'all-inherited';
+    readonly conditions: 'base' | 'all';
+    readonly origin: OpOrigin;
+};
+/** Author-emitted op data: identical union minus `origin` (the scheduler stamps origin). */
+type RewriteOpDraft = DistributiveOmit<RewriteOp, 'origin'>;
+type ElementLike = IRElement | DeepReadonly<IRElement>;
+type NodeLike = IRNode | DeepReadonly<IRNode>;
+/**
+ * Pattern-kit's factory: produces op DRAFTS (no origin) and builds detached NodeSpecs purely —
+ * it never touches doc.alloc/doc.nodes, so `evaluate` stays pure (review-2).
+ */
+interface RewriteFactory {
+    unwrap(target: ElementLike): RewriteOpDraft;
+    removeNode(target: NodeLike): RewriteOpDraft;
+    replaceWith(target: NodeLike, replacement: NodeSpec): RewriteOpDraft;
+    wrap(target: NodeLike, wrapper: ElementSpec): RewriteOpDraft;
+    insertBefore(anchor: NodeLike, node: NodeSpec): RewriteOpDraft;
+    insertAfter(anchor: NodeLike, node: NodeSpec): RewriteOpDraft;
+    moveNode(target: NodeLike, newParent: ElementLike, index: number): RewriteOpDraft;
+    mergeSiblings(first: NodeLike, second: NodeLike): RewriteOpDraft;
+    setClassList(target: ElementLike, style: StyleMap, preserveOpaque?: boolean): RewriteOpDraft;
+    mergeStyle(target: ElementLike, source: ElementLike | null, style: StyleMap, onConflict?: StyleConflictPolicy): RewriteOpDraft;
+    /**
+     * Folds inheritable declarations. `conditions:'all'` folds across every StyleCondition
+     * (states/media/pseudo-element), not just BASE_CONDITION (review-1 major). Relative-unit
+     * declarations are rejected by the applier with DF_RELATIVE_UNIT_FOLD.
+     */
+    foldInheritedStyles(from: ElementLike, into: ElementLike | readonly ElementLike[], opts?: {
+        only?: readonly CssProperty[];
+        conditions?: 'base' | 'all';
+    }): RewriteOpDraft;
+    element(spec: ElementSpec): NodeSpec;
+    text(value: string): NodeSpec;
+    keep(node: NodeLike): NodeSpec;
+}
+type PassPhase = 'flatten' | 'compress' | 'extract';
+type PassCategory = `${PassPhase}/${string}`;
+type Captures = Record<string, unknown>;
+/** Read-only style predicate over a normalized StyleMap (queries MEANING, not strings). */
+type StylePredicate = (sm: StyleMap) => boolean;
+/**
+ * Relational precondition (review-2 blocker): describes ancestor/sibling/child subtree shape AND
+ * ancestor LAYOUT context (review-4 blocker) so fuzzProve generates trees that exercise the
+ * relational + parent-constraint branches, not just node-local ones.
+ */
+interface TreeShapeSketch {
+    readonly tag?: string | readonly string[];
+    readonly requiredComputed?: Readonly<Record<string, string>>;
+    readonly meta?: Partial<Record<keyof NodeMeta, boolean>>;
+    readonly children?: readonly TreeShapeSketch[];
+}
+type ParentLayoutContext = 'block-flow' | 'flex-item' | 'flex-item-stretch' | 'grid-item' | 'fixed-size-ancestor' | 'percentage-sized-child' | 'inline-context';
+interface PreconditionSketch {
+    readonly requiredComputed?: Readonly<Record<string, string>>;
+    readonly childCount?: {
+        readonly min?: number;
+        readonly max?: number;
+    };
+    readonly forbid?: readonly string[];
+    readonly ancestor?: TreeShapeSketch;
+    readonly siblings?: readonly TreeShapeSketch[];
+    readonly childShapes?: readonly TreeShapeSketch[];
+    readonly parentContexts?: readonly ParentLayoutContext[];
+}
+interface PatternDoc {
+    readonly title: string;
+    readonly summary: string;
+    readonly before?: string;
+    readonly after?: string;
+    readonly safetyRationale?: string;
+}
+/** Result of a successful match: op drafts (origin stamped later) + optional captures/diagnostics. */
+interface MatchResult<C extends Captures = Captures> {
+    readonly ops: readonly RewriteOpDraft[];
+    readonly captures?: C;
+    readonly diagnostics?: readonly Diagnostic[];
+}
+interface MatchContext {
+    readonly node: DeepReadonly<IRElement>;
+    readonly doc: DeepReadonly<IRDocument>;
+    readonly resolver: StyleResolver;
+    readonly selectors: SelectorIndex;
+    readonly safety: SafetyLevel;
+    readonly phase: PassPhase;
+    readonly iteration: number;
+    parent(): DeepReadonly<IRElement> | null;
+    elementChildren(): readonly DeepReadonly<IRElement>[];
+    onlyElementChild(): DeepReadonly<IRElement> | null;
+    computed(): StyleMap;
+    computedOf(n: NodeLike): StyleMap;
+    isOpaque(n?: ElementLike): boolean;
+    ancestors(): readonly DeepReadonly<IRElement>[];
+    closest(pred: (el: DeepReadonly<IRElement>) => boolean): DeepReadonly<IRElement> | null;
+    prevSibling(): DeepReadonly<IRNode> | null;
+    nextSibling(): DeepReadonly<IRNode> | null;
+    nthChildIndex(): number;
+}
+/** Context handed to the `rewrite` phase: a MatchContext plus the typed captures. */
+interface RewriteContext<C extends Captures = Captures> extends MatchContext {
+    readonly captures: C;
+}
+interface Pattern {
+    readonly name: PatternName;
+    readonly category: PassCategory;
+    readonly safety: SafetyLevel;
+    readonly priority?: number;
+    readonly precondition?: PreconditionSketch;
+    readonly doc?: PatternDoc;
+    /** Pure. Returns a MatchResult (op drafts) or null on no-match. MUST NOT mutate. */
+    evaluate(ctx: MatchContext, rw: RewriteFactory): MatchResult | null;
+}
+interface Pass {
+    readonly phase: PassPhase;
+    readonly category: PassCategory;
+    readonly patterns: readonly Pattern[];
+}
+interface FixpointConfig {
+    readonly maxIterations: number;
+    readonly phases: Partial<Record<PassPhase, number>>;
+    readonly onBudgetExhausted: 'warn' | 'error';
+    readonly detectOscillation: boolean;
+}
+type HaltReason = 'converged' | 'budget' | 'oscillation' | 'error';
+interface PhaseRunResult {
+    readonly phase: PassPhase;
+    readonly iterations: number;
+    readonly converged: boolean;
+    readonly haltReason: HaltReason;
+    readonly touched: ReadonlySet<IRNodeId>;
+    readonly diagnostics: readonly Diagnostic[];
+}
+interface RewriteGroup {
+    readonly pattern: PatternName;
+    readonly anchor: IRNodeId;
+    readonly ops: readonly RewriteOp[];
+}
+interface ApplyContext {
+    readonly doc: IRDocument;
+    readonly safetyCeiling: SafetyLevel;
+    readonly normalizer: StyleNormalizer;
+    readonly selectors: SelectorIndex;
+    readonly resolver: StyleResolver;
+}
+interface StructuralInverse {
+    readonly kind: 'structural';
+    readonly describe: string;
+    readonly snapshot: unknown;
+}
+interface AppliedOp {
+    readonly op: RewriteOp;
+    readonly inverse: RewriteOp | StructuralInverse;
+}
+interface OpValidationIssue {
+    readonly op: RewriteOp;
+    readonly code: DiagnosticCode;
+    readonly message: string;
+}
+interface SkippedOpGroup {
+    readonly group: RewriteGroup;
+    readonly issues: readonly OpValidationIssue[];
+}
+interface ApplyResult {
+    readonly touched: ReadonlySet<IRNodeId>;
+    readonly removed: ReadonlySet<IRNodeId>;
+    readonly created: ReadonlySet<IRNodeId>;
+    readonly appliedGroups: number;
+    readonly skipped: readonly SkippedOpGroup[];
+    readonly journal: readonly AppliedOp[];
+    readonly diagnostics: readonly Diagnostic[];
+}
+interface PassManager {
+    run(doc: IRDocument, ctx: ApplyContext, config?: FixpointConfig): readonly PhaseRunResult[];
+}
+interface FrontendConfig {
+    readonly jsxImportSource?: string;
+    readonly preserveComments?: boolean;
+    readonly [key: string]: unknown;
+}
+interface FrontendParseContext {
+    readonly id: string;
+    readonly kind: FileKind;
+    readonly resolver: StyleResolver;
+    readonly normalizer: StyleNormalizer;
+    readonly config: FrontendConfig;
+    onDiagnostic(d: Diagnostic): void;
+    babelAst?: unknown;
+}
+interface ParseResult {
+    readonly doc: IRDocument;
+    readonly diagnostics: readonly Diagnostic[];
+}
+interface Frontend {
+    readonly name: string;
+    readonly langs: readonly FileKind[];
+    canParse(id: string, code: string): boolean;
+    parse(code: string, ctx: FrontendParseContext): ParseResult;
+}
+interface ReindentSpec {
+    readonly baseIndent: string;
+    readonly delta: number;
+}
+interface TextEdit {
+    readonly span: SourceSpan;
+    readonly replacement: string;
+    readonly reindent?: ReindentSpec;
+    readonly origin: string;
+}
+interface EditPlan {
+    readonly moduleId: string;
+    readonly ops: readonly RewriteOp[];
+    readonly provenance: ReadonlyMap<number, PatternName>;
+}
+interface EncodedSourceMap {
+    readonly version: 3;
+    readonly sources: readonly string[];
+    readonly sourcesContent?: readonly (string | null)[];
+    readonly names: readonly string[];
+    readonly mappings: string;
+    readonly file?: string;
+}
+interface BackendContext {
+    readonly normalizer: StyleNormalizer;
+    readonly resolver: StyleResolver;
+    readonly sink: SyntheticSink;
+    readonly eol: '\n' | '\r\n';
+    onDiagnostic(d: Diagnostic): void;
+}
+interface CodegenResult {
+    readonly code: string;
+    readonly map: EncodedSourceMap | null;
+    readonly edits: readonly TextEdit[];
+    readonly diagnostics: readonly Diagnostic[];
+}
+interface Backend {
+    readonly name: string;
+    readonly langs: readonly FileKind[];
+    print(doc: IRDocument, plan: EditPlan, ctx: BackendContext): CodegenResult;
+}
+interface PipelineConfig {
+    readonly safety: SafetyLevel;
+    readonly fixpoint?: Partial<FixpointConfig>;
+    readonly preserveComments?: boolean;
+    readonly emitSourceMap?: boolean;
+}
+interface PipelineInput {
+    readonly code: string;
+    readonly id: string;
+    readonly kind: FileKind;
+    readonly frontend: Frontend;
+    readonly backend: Backend;
+    readonly resolver: StyleResolver;
+    readonly normalizer: StyleNormalizer;
+    readonly passes: readonly Pass[];
+    readonly config?: PipelineConfig;
+    readonly reporter?: Reporter;
+    readonly babelAst?: unknown;
+}
+interface PipelineStats {
+    readonly nodesIn: number;
+    readonly nodesOut: number;
+    readonly opsApplied: number;
+    readonly iterations: Readonly<Record<PassPhase, number>>;
+    readonly durationMs: number;
+}
+interface PipelineOutput {
+    readonly code: string;
+    readonly map: EncodedSourceMap | null;
+    readonly changed: boolean;
+    readonly touched: readonly SourceSpan[];
+    readonly diagnostics: readonly Diagnostic[];
+    readonly stats: PipelineStats;
+    readonly doc: IRDocument;
+    readonly editPlan: EditPlan;
+}
+/** The pure single-file pipeline. Adapters/orchestrator call this; the verifier reuses it. */
+interface Pipeline {
+    run(input: PipelineInput): PipelineOutput;
+}
+
+export type { EncodedSourceMap as $, AttrMap as A, BackrefTable as B, CssProperty as C, PreconditionSketch as D, ElementLike as E, FrontendKind as F, PatternDoc as G, Diagnostic as H, IRNodeId as I, ApplyResult as J, RewriteGroup as K, ApplyContext as L, MatchContext as M, NodeLike as N, RewriteOp as O, Pattern as P, FixpointConfig as Q, RewriteOpDraft as R, StyleMap as S, StyleResolver as T, SelectorIndex as U, Visitor as V, Pass as W, PassManager as X, PhaseRunResult as Y, Pipeline as Z, SyntheticSink as _, StyleConflictPolicy as a, TextEdit as a$, AppliedOp as a0, AttrValue as a1, Backend as a2, BackendContext as a3, Brand as a4, ClassListForm as a5, ClassSegment as a6, ClassToken as a7, CodegenResult as a8, CommentSpec as a9, ParentLayoutContext as aA, ParseResult as aB, PassPhase as aC, PassTraceEntry as aD, PatternName as aE, PipelineConfig as aF, PipelineInput as aG, PipelineOutput as aH, PipelineStats as aI, Position as aJ, ReindentSpec as aK, Reporter as aL, ResolveInput as aM, ResolveResult as aN, ResolverDiagnostic as aO, RewriteContext as aP, SelectorUsage as aQ, Severity as aR, SkippedOpGroup as aS, SourceFile as aT, SourceFileId as aU, StructuralInverse as aV, StyleBlock as aW, StyleDecl as aX, StyleOrigin as aY, StylePredicate as aZ, SyntheticClass as a_, CssValue as aa, DeclSignature as ab, DeepReadonly as ac, DiagnosticCode as ad, DistributiveOmit as ae, EditPlan as af, ElementSpec as ag, EmitContext as ah, EmitResult as ai, ExprKind as aj, ExprRecord as ak, ExprSpec as al, FileKind as am, FragmentSpec as an, Frontend as ao, FrontendConfig as ap, FrontendParseContext as aq, HaltReason as ar, IRNodeBase as as, IRNodeKind as at, InheritedPropertyTable as au, NodeRefSpec as av, OpOrigin as aw, OpValidationIssue as ax, OpaqueReason as ay, OpaqueToken as az, NodeSpec as b, TextSpec as b0, TreeShapeSketch as b1, VisitContext as b2, VisitSignal as b3, StyleNormalizer as c, StyleCondition as d, ConditionKey as e, IRNamespace as f, ClassList as g, InlineStyle as h, SourceSpan as i, NodeMeta as j, Backref as k, IRNode as l, IRComment as m, IRDocument as n, IRElement as o, ExprRef as p, IRExpr as q, ExprRegistry as r, IRFragment as s, IdAllocator as t, IRText as u, SafetyLevel as v, Captures as w, RewriteFactory as x, MatchResult as y, PassCategory as z };