/** The only AuthoringPlan wire format accepted by this preview release. */
declare const AUTHORING_PLAN_VERSION$1: 1;
type JsonPrimitive = string | number | boolean | null;
type JsonValue = JsonPrimitive | JsonValue[] | {
    [key: string]: JsonValue;
};
type AuthoringFieldMode = 'fixed' | 'editable' | 'override';
type AuthoringStyleStrategy = 'native' | 'scoped-css' | 'mixed';
type AuthoringStyleOutcomeKind = 'native' | 'token' | 'scoped-css' | 'dropped';
type AuthoringAssetStatus = 'ready' | 'missing' | 'external';
type AuthoringFileOperation = 'create' | 'replace';
type AuthoringLockMode = 'insert' | 'all' | 'contentOnly' | 'none';
/** The authored material that was actually analysed to produce a registered-block plan. */
type AuthoringSourceFormat = 'html' | 'directory';
interface AuthoringSource {
    /** The source entry as supplied to the authoring run (or a stable stdin/inline label). */
    entry: string;
    /** SHA-256 of the exact source bytes analysed by Block Runner. */
    sha256: string;
    format: AuthoringSourceFormat;
}
/** A source position retained in the analysis ledger. */
interface AuthoringCoverageLocation {
    path?: string;
    selector?: string;
    htmlLine?: number;
    htmlColumn?: number;
    offset?: number;
}
type AuthoringCoverageStyleOutcome = 'native' | 'preset' | 'literal' | 'scoped-css' | 'warned' | 'blocked';
/** One source declaration and its final destination disposition. */
interface AuthoringCoverageStyle {
    declarationId?: string;
    ruleId?: string;
    property: string;
    value: string;
    outcome: AuthoringCoverageStyleOutcome;
    /** Whether the declaration came from parity CSS or explicit editor-only CSS. */
    scope: 'shared' | 'editor';
    reason?: string;
    atRules: string[];
    source?: AuthoringCoverageLocation;
    /** Hash-bound component-local selector used by the generated stylesheet, when rewritten. */
    transportSelector?: string;
    /**
     * Required when a source declaration is carried by a particular native block rather than
     * residual CSS. This prevents another node with the same property/value from satisfying
     * source coverage by accident.
     */
    node?: string;
    /** The WP 7.1 responsive style state that carries this native declaration, when applicable. */
    responsive?: 'mobile' | 'tablet';
    /** Exact target theme preset provenance for a preset outcome. */
    preset?: {
        category: 'color' | 'spacing' | 'font-size' | 'font-family';
        slug: string;
    };
    /** Native destinations emitted in addition to, never instead of, the source declaration. */
    nativeTargets?: Array<{
        node: string;
        role: 'button-link' | 'button-wrapper-reset' | 'image' | 'caption' | 'grid-container';
        selector: string;
        important?: boolean;
        intrinsic?: {
            width: string;
            height: string;
            aspectRatio: string;
        };
    }>;
}
type AuthoringCoverageAssetOutcome = 'prepared' | 'copied' | 'uploaded' | 'reused' | 'external' | 'unresolved' | 'blocked';
/** One concrete source asset reference and its final package/destination disposition. */
interface AuthoringCoverageAsset {
    reference: string;
    rewritten?: string;
    kind: 'image' | 'font' | 'stylesheet' | 'media' | 'other';
    outcome: AuthoringCoverageAssetOutcome;
    reason?: string;
    /** Hash of the local bytes when this reference resolved to a prepared package asset. */
    sha256?: string;
    destination?: string;
    source?: AuthoringCoverageLocation;
}
/** Hashes and complete ledgers produced by the deterministic HTML analysis pass. */
interface AuthoringCoverage {
    /** Effective stylesheet bytes scanned by the authoring pass. */
    stylesheet?: {
        entry: string;
        sha256: string;
    };
    /** Explicit editor-only stylesheet bytes scanned by the authoring pass. */
    editorStylesheet?: {
        entry: string;
        sha256: string;
    };
    /** Destination style inputs actually consulted while deciding ownership. */
    styleContext?: AuthoringStyleContext;
    /** Explicit source-bound decision to contain foundation rules inside this component. */
    foundation?: 'component';
    /** One entry per source declaration observed by the authoring pass. */
    styles: AuthoringCoverageStyle[];
    /** One entry per concrete asset reference observed by the authoring pass. */
    assets: AuthoringCoverageAsset[];
}
/** A hash-bound description of the target style environment, never a request to edit it. */
interface AuthoringStyleContext {
    theme?: {
        slug?: string;
        version?: string;
        settingsSha256?: string;
    };
    viewports?: Partial<Record<'mobile' | 'tablet', {
        min?: string;
        max?: string;
    }>>;
    unresolvedVariables?: string[];
    limitations?: string[];
}
/**
 * The registered block this plan is intended to create. `directory` is a safe relative suggested
 * package location used when preview has no explicit `--output-dir`; an explicit CLI destination
 * always takes precedence so its previewed path can be passed unchanged to `author write`.
 */
interface AuthoringTarget {
    /** WordPress block name, for example `my-plugin/feature-grid`. */
    name: string;
    title: string;
    description?: string;
    category?: string;
    icon?: string;
    textDomain?: string;
    wordpress?: string;
    directory?: string;
    /**
     * Additional declarative block.json metadata. It is hash-bound and rendered in preview.
     * Static capability checks happen at compilation, where unsafe code-loading forms can be
     * rejected without narrowing this transport to a particular vendor schema revision.
     */
    metadata?: {
        [key: string]: JsonValue;
    };
}
interface AuthoringNodeLock {
    move?: boolean;
    remove?: boolean;
}
/** A native block and its native children; this is never HTML. */
interface AuthoringStructureNode {
    /** Optional stable reference used by a field's `node` property. */
    id?: string;
    block: string;
    label?: string;
    attributes?: {
        [key: string]: JsonValue;
    };
    lock?: AuthoringNodeLock;
    children?: AuthoringStructureNode[];
}
/** A reviewed source-content change made while binding an authoring proposal. */
interface AuthoringSourceDecision {
    action: 'add' | 'replace' | 'omit';
    sourceRef: string;
    node?: string;
    attribute?: string;
    original?: JsonValue;
    value?: JsonValue;
    reason: string;
    source?: AuthoringCoverageLocation;
}
/** A value an editor can, cannot, or may override in a pattern. */
interface AuthoringField {
    id: string;
    label: string;
    mode: AuthoringFieldMode;
    type?: string;
    node?: string;
    attribute?: string;
    default?: JsonValue;
    description?: string;
}
/** Locking that applies to the authored block as a whole. */
interface AuthoringLocking {
    mode: AuthoringLockMode;
    move?: boolean;
    remove?: boolean;
    insert?: boolean;
}
/** The disposition of one source style after native-style mapping. */
interface AuthoringStyleOutcome {
    property: string;
    outcome: AuthoringStyleOutcomeKind;
    value?: string;
    token?: string;
    reason?: string;
}
interface AuthoringStyles {
    strategy: AuthoringStyleStrategy;
    outcomes: AuthoringStyleOutcome[];
    /** Explicit compiler policy for component-contained foundation selectors. */
    foundation?: 'component';
    /** Component-local selectors before the compiler adds its owned block root. */
    rules?: AuthoringCssRule[];
    /** Supplemental editor affordances, subject to the same scoping and asset checks. */
    editorRules?: AuthoringCssRule[];
    /**
     * Hash-confirmed, licensed faces shared by the editor and frontend. Each face points at the
     * corresponding `assets[]` entry; source paths and hashes stay in that one asset record. Font
     * faces are deliberately not an editor-only field: `style.scss` is loaded in both contexts,
     * while `editor.scss` is supplemental and must not duplicate a face.
     */
    fonts?: AuthoringFontFace[];
}
/** A checked @font-face descriptor whose source is resolved from a confirmed asset ID. */
interface AuthoringFontFace {
    assetId: string;
    family: string;
    fontStyle?: string;
    fontWeight?: string;
    fontStretch?: string;
    fontDisplay?: string;
    unicodeRange?: string;
}
/** The explicit ownership/license decision attached to one bundled font asset. */
interface AuthoringFontLicense {
    ownership: string;
    license: string;
    notice?: string;
}
interface AuthoringCssDeclaration {
    property: string;
    value: string;
    important?: boolean;
}
/** Structured CSS only: no imports, Sass, executable fragments, or unscoped output. */
type AuthoringCssRule = {
    kind: 'style';
    selector: string;
    declarations: AuthoringCssDeclaration[];
    /** Compiler-owned supplemental transport; source rules deliberately omit this field. */
    generated?: 'native-adapter-target' | 'native-adapter-wrapper-reset';
} | {
    kind: 'conditional';
    name: 'media' | 'supports' | 'container';
    prelude: string;
    rules: AuthoringCssRule[];
};
interface AuthoringPatternOverride {
    field: string;
    label?: string;
    description?: string;
}
interface AuthoringPattern {
    ready: boolean;
    overrides: AuthoringPatternOverride[];
}
interface AuthoringAsset {
    id: string;
    source: string;
    kind?: string;
    /** A path below the generated package, when the asset is copied into it. */
    destination?: string;
    status?: AuthoringAssetStatus;
    required?: boolean;
    /** SHA-256 of a local source file, required before it may be copied. */
    sha256?: string;
    /** Explicit ownership and license record required for a bundled WOFF/WOFF2 asset. */
    fontLicense?: AuthoringFontLicense;
    /** Explicit native media attributes which use this bundled image. */
    uses?: Array<{
        node: string;
        attribute: 'url';
    }>;
}
/**
 * A prospective generated file for low-level destination writers. The registered-block compiler
 * deliberately rejects `content`: declarative AuthoringPlans may only select its own output paths.
 */
interface AuthoringFile {
    /** Portable, relative POSIX path below the output directory. */
    path: string;
    kind?: string;
    content?: string;
    /** Replacing a collision requires this separate, hash-bound approval decision. */
    operation?: AuthoringFileOperation;
}
/**
 * A complete, declarative input to registered-block authoring.
 *
 * The contract keeps human decisions separate from generated source: the structure and editor
 * model are explicit, while registered-block compilation treats files as compiler-owned output
 * paths and collision policy rather than executable source.
 */
interface AuthoringPlan$1 {
    version: typeof AUTHORING_PLAN_VERSION$1;
    generatorVersion: string;
    target: AuthoringTarget;
    /** Present on plans produced by HTML analysis; absent on a hand-authored plan. */
    source?: AuthoringSource;
    /** Complete, hash-bound dispositions from the HTML analysis pass. */
    coverage?: AuthoringCoverage;
    structure: AuthoringStructureNode[];
    /** Present only for proposal-derived plans; legacy plan serialization is unchanged. */
    sourceDecisions?: AuthoringSourceDecision[];
    /** Explicit direct-child insertion policy; defaults to the initial template's direct children. */
    allowedBlocks?: string[];
    fields: AuthoringField[];
    locking: AuthoringLocking;
    styles: AuthoringStyles;
    pattern: AuthoringPattern;
    assets: AuthoringAsset[];
    files: AuthoringFile[];
    warnings: string[];
}
declare class AuthoringPlanValidationError$1 extends Error {
    constructor(message: string);
}
/**
 * Parse (when necessary), validate, and normalize an untrusted AuthoringPlan.
 *
 * Normalization fills the deliberately boring defaults, rejects unknown fields, and returns a
 * fresh JSON-only value. It is also the single gate used by hashing and rendering, so a preview
 * cannot accidentally describe a different object from the one that is confirmed later.
 */
declare function validateAuthoringPlan$1(input: unknown): AuthoringPlan$1;
/**
 * Validate and return a recursively key-sorted plan object. Array order is deliberately retained:
 * it describes native child order and is therefore material. Use `serializeAuthoringPlan` when a
 * wire representation is required.
 */
declare function canonicalizeAuthoringPlan$1(input: unknown): AuthoringPlan$1;
/** Stable canonical JSON, with recursively sorted object keys and preserved array order. */
declare function serializeAuthoringPlan$1(input: unknown): string;
/** SHA-256 of canonical JSON, as lower-case hexadecimal (without a display-only prefix). */
declare function hashAuthoringPlan$1(input: unknown): string;
/**
 * Plan paths are portable paths inside an output root. They cannot select a parent, an absolute
 * location, a Windows drive/UNC path, or an empty component that normalisation could reinterpret.
 */
declare function isSafeAuthoringRelativePath$1(value: string, options?: {
    allowDot?: boolean;
}): boolean;

/** Pinned local registry and the deliberately narrow static-authoring policy. */
declare const AUTHORING_NATIVE_POLICY_VERSION: "1";
interface AuthoringRegistryIdentity {
    /** Target WordPress schema/registry contract; package versions below are the observed evidence. */
    wordpress: '7.1';
    blockLibrary: string;
    blocks: string;
    policy: typeof AUTHORING_NATIVE_POLICY_VERSION;
}

/**
 * Source-style graph utilities for generated blocks.
 *
 * Tailwind is compiled only by the project's explicitly supplied, pinned compiler. A Tailwind
 * class is not CSS, and guessing its declaration from a token would make the generated block
 * depend on an unknown version, configuration, plugin set, source set, and browser target. The
 * compiler receives the complete materialized graph and its result is the only Tailwind CSS this
 * module will author.
 *
 * The scanner is deliberately small and conservative. It preserves the conditional constructs that
 * can safely remain in a block stylesheet (`@media`, `@supports`, and `@container`) and records all
 * other global or unsupported constructs rather than silently flattening or dropping them.
 */
type BuildGraphField = 'cssEntries' | 'imports' | 'directives' | 'sources' | 'safelist' | 'plugins' | 'environment' | 'browserTarget' | 'compiler';
/**
 * The inputs that determine a Tailwind (or Tailwind-like) generated stylesheet. Empty arrays are
 * meaningful: they say that the author explicitly has no imports, safelist, or plugins. Omitted
 * fields are not meaningful and therefore cannot support a fidelity claim.
 */
interface CssBuildGraph extends TailwindBuildGraph {
    cssEntries?: readonly string[];
    imports?: readonly string[];
    directives?: readonly string[];
    sources?: readonly string[];
    safelist?: readonly string[];
    plugins?: readonly string[];
    environment?: Readonly<Record<string, string | number | boolean | null | undefined>>;
    browserTarget?: string | readonly string[];
}
interface BuildGraphIssue {
    field: BuildGraphField;
    status: 'warning' | 'blocked';
    reason: string;
}
interface BuildGraphValidation {
    /** All required graph inputs were supplied and entry/source values are non-empty. */
    complete: boolean;
    /** Tailwind mode was explicitly declared by the caller or by supplying a graph. */
    tailwindDetected: boolean;
    /** The supplied CSS is a compiled, self-contained stylesheet rather than Tailwind source. */
    compiled: boolean;
    /** A pinned compiler actually generated and, when supplied, matched this CSS. */
    provenanceVerified: boolean;
    /** `--tw-*` variables referenced by the CSS but not defined anywhere in that CSS. */
    unresolvedVariables: string[];
    /** Tailwind fidelity is blocked for an incomplete graph or an uncompiled/incomplete CSS result. */
    blocked: boolean;
    missing: BuildGraphField[];
    issues: BuildGraphIssue[];
}
interface BuildGraphValidationOptions {
    /** Compiled or source CSS to inspect for Tailwind directives/variables. */
    css?: string;
    /** Explicitly declare Tailwind mode when the compiled CSS has no recognizable source token. */
    tailwindDetected?: boolean;
    /** Set only after `compileTailwindBuildGraph()` produced the CSS being validated. */
    provenanceVerified?: boolean;
}
/**
 * Validate the source inputs needed to make a Tailwind fidelity statement. Tailwind mode is not
 * considered usable until a caller has also run `compileTailwindBuildGraph()` and marked the exact
 * output as verified. Keeping this synchronous utility strict prevents a complete-looking graph
 * plus independently supplied CSS from being mistaken for compiler provenance.
 */
declare function validateCssBuildGraph$1(graph: CssBuildGraph | undefined, options?: BuildGraphValidationOptions): BuildGraphValidation;
/** True only for Tailwind *source* that still needs a compiler, never for compiled declarations. */
declare function hasTailwindSignal$1(css: string): boolean;
interface TailwindCompilationOptions {
    /** Design HTML path, used as the base for graph paths when available. */
    sourcePath?: string;
    /** CSS supplied as purported compiler output. It must exactly match when present. */
    expectedCss?: string;
}
interface TailwindCompilation {
    css?: string;
    issues: BuildGraphIssue[];
    /** True only when the compiler ran and its output matched the supplied output (if any). */
    verified: boolean;
}
/**
 * Materialize and compile the declared Tailwind graph. This intentionally has no fallback that
 * infers a utility from class names or accepts a prebuilt stylesheet on trust: the supplied
 * compiler is the project's pin for Tailwind, plugins, custom variants, and browser targeting.
 */
declare function compileTailwindBuildGraph$1(graph: CssBuildGraph, options?: TailwindCompilationOptions): Promise<TailwindCompilation>;
interface CssPosition {
    offset: number;
    line: number;
    column: number;
}
interface CssSourceRange {
    start: CssPosition;
    end: CssPosition;
}
interface CssDeclaration {
    id: string;
    property: string;
    value: string;
    important: boolean;
    source: CssSourceRange;
    /** Exact raw value span, excluding declaration whitespace but retaining `!important`. */
    valueSource: CssSourceRange;
}
interface CssStyleRule {
    id: string;
    kind: 'style';
    selector: string;
    declarations: CssDeclaration[];
    source: CssSourceRange;
    /** Present for CSS nesting. Nested selectors are parsed and ledgered, then conservatively blocked. */
    nestedIn?: string;
    /** Internal provenance for rules inserted by the native markup adapter. */
    generated?: 'native-adapter-target' | 'native-adapter-wrapper-reset';
}
interface CssConditionalRule {
    id: string;
    kind: 'conditional';
    name: 'media' | 'supports' | 'container';
    prelude: string;
    rules: CssRule[];
    source: CssSourceRange;
}
interface CssBlockedRule {
    id: string;
    kind: 'blocked';
    name: string;
    prelude: string;
    declarations: CssDeclaration[];
    rules: CssRule[];
    reason: string;
    source: CssSourceRange;
}
type CssRule = CssStyleRule | CssConditionalRule | CssBlockedRule;
type StyleLedgerOutcome = 'pending' | 'native' | 'preset' | 'literal' | 'scoped-css' | 'warned' | 'blocked';
/** One and only one of these entries is created for every parsed source declaration. */
interface SourceStyleLedgerEntry {
    declarationId: string;
    ruleId: string;
    property: string;
    value: string;
    important: boolean;
    source: CssSourceRange;
    atRules: string[];
    outcome: StyleLedgerOutcome;
    reason?: string;
}
interface CssRuleRecord {
    ruleId: string;
    kind: CssRule['kind'];
    prelude: string;
    source: CssSourceRange;
    outcome: 'pending' | 'scoped-css' | 'blocked';
    reason?: string;
}
interface CssStylesheet {
    rules: CssRule[];
    ledger: SourceStyleLedgerEntry[];
    ruleRecords: CssRuleRecord[];
}
/**
 * Scan a stylesheet without flattening its conditional structure. CSS comments, quotes, url(),
 * attribute selectors, and escaped quotes are respected while finding braces and declarations.
 * Malformed tail content becomes a blocked rule record instead of disappearing.
 */
declare function scanStylesheet$1(css: string): CssStylesheet;
interface DeclarationDisposition {
    outcome: Exclude<StyleLedgerOutcome, 'pending' | 'scoped-css'> | 'scoped-css';
    reason?: string;
}
interface ScopeStylesheetOptions {
    /** The deterministic generated-block root, e.g. `.wp-block-acme-hero`. */
    root: string;
    /**
     * Called only for a safe, local style rule. Returning native/preset/literal leaves that
     * declaration out of parity CSS; returning nothing keeps it as scoped CSS.
     */
    disposition?: (declaration: CssDeclaration, rule: CssStyleRule, context: {
        conditional: boolean;
    }) => DeclarationDisposition | undefined;
    /** Rewrite source selector atoms before the root prefix is applied. */
    selectorTransform?: (selector: string, rule: CssStyleRule) => string;
    /** Explicitly contain safe foundation selectors within the generated component. */
    foundation?: 'component';
}
interface ScopedStylesheet {
    root: string;
    rules: CssRule[];
    /** The same retained rules before adding the root, for the confirmed-plan compiler. */
    localRules: CssRule[];
    ledger: SourceStyleLedgerEntry[];
    ruleRecords: CssRuleRecord[];
    css: string;
}
/**
 * Scope safe local selectors under a generated block root. Foundation rules and selectors that can
 * name or depend on the document outside that root are not rewritten: their declarations and rule
 * records are explicitly blocked. This is intentionally stricter than merely prefixing every
 * selector, because that would turn Preflight into a misleading claim of semantic equivalence.
 */
declare function scopeStylesheet$1(stylesheet: CssStylesheet, options: ScopeStylesheetOptions): ScopedStylesheet;
/** Render the original rule order in a normalized, deterministic format. */
declare function renderResidualCss$1(stylesheet: Pick<ScopedStylesheet, 'rules'>): string;
/**
 * Scope a safe selector list without changing the authored selector's cascade weight.
 *
 * The generated block root must contain every match, but its class is an implementation detail:
 * placing it directly in the selector would add one class of specificity and make otherwise
 * deliberately weak rules (notably `:where(...)`) win against their source peers. `:where()`
 * supplies the containment boundary with zero specificity.
 */
declare function scopeLocalSelectorList$1(selectorList: string, root: string, options?: {
    foundation?: 'component';
}): {
    ok: true;
    selector: string;
    foundation?: 'component' | 'document-base';
} | {
    ok: false;
    reason: string;
};

/** The only outcomes an authored CSS asset can have in a generated bundle. */
type AssetOutcome$1 = 'prepared' | 'copied' | 'external' | 'unresolved' | 'blocked';
interface PreparedCssAsset {
    source: string;
    destination: string;
    content: Buffer;
    sha256: string;
    /** The source URL's transport class.  A font is never treated as an image/media asset. */
    kind: CssAssetKind;
}
/** The use is deliberately descriptive; it never implies a WordPress attachment ID. */
type CssAssetKind = 'asset' | 'font';
/**
 * The minimum affirmative decision needed to redistribute a font in a generated block.
 *
 * A boolean such as `allowFontLicense: true` cannot establish which file was reviewed or who
 * owns its redistribution rights.  The reference, exact source path, and byte hash bind the
 * decision to one concrete file; `ownership` and `license` make the human decision auditable.
 */
interface FontLicenseDecision {
    /** Exact CSS URL spelling this decision covers (before any package-relative rewrite). */
    reference: string;
    /** Exact local file that was reviewed, normally an absolute path below the source root. */
    source: string;
    /** SHA-256 of the reviewed file bytes. */
    sha256: string;
    /** Human-readable rights-holder or ownership decision; it is intentionally not inferred. */
    ownership: string;
    /** SPDX identifier, license URL, or other human-readable license record. */
    license: string;
    /** Optional supplied redistribution notice, copied into the generated source record verbatim after safe escaping. */
    notice?: string;
}
interface FontAssetWarning {
    reference?: string;
    family?: string;
    reason: string;
    source?: CssAssetLocation;
}
interface CssAssetLocation {
    /** The supplied CSS source path, when one was available. */
    path?: string;
    /** Zero-based offset in `sourceCss`. */
    offset: number;
    /** One-based line and column, useful for a conversion report. */
    line: number;
    column: number;
}
/**
 * A literal `url(...)` reference found in CSS. `start`/`end` delimit the complete function,
 * whereas `url` is the unquoted, CSS-unescaped reference inside it.
 */
interface CssUrlReference {
    raw: string;
    url: string;
    start: number;
    end: number;
    location: CssAssetLocation;
    kind: CssAssetKind;
    /** `url` is a CSS url() function; `string` is a direct image-set() source string. */
    syntax?: 'url' | 'string';
}
/** One explicit ledger entry for one authored `url(...)` reference. */
interface CssAssetLedgerEntry extends CssUrlReference {
    outcome: AssetOutcome$1;
    reason: string;
    /** The filesystem source used for a copied asset. Never set for a remote asset. */
    sourceAssetPath?: string;
    /** The copied destination. Never set for an unresolved, external, or blocked asset. */
    destinationAssetPath?: string;
    /** The URL substituted into the returned CSS. Omitted when the source CSS is left untouched. */
    rewrittenUrl?: string;
}
/**
 * Inputs for CSS asset processing. `sourcePath` names the authored stylesheet (or the HTML file
 * containing an inline stylesheet); relative URLs are resolved from its directory. The result CSS
 * is intended to live beside `destinationAssetDir`, so the default rewritten URLs are
 * `./<assets-dir-name>/<hashed-file>`.
 */
interface RewriteCssAssetsOptions {
    /** Collect bytes without touching the destination; the owner writes only after confirmation. */
    prepareAsset?: (asset: PreparedCssAsset) => void;
    sourcePath?: string;
    /**
     * Boundary for relative local URLs. Defaults to the directory containing `sourcePath`; a CSS
     * reference may name a file below this directory, but never a parent or sibling. Supplying an
     * asset root is useful when a stylesheet lives in a nested `css/` directory beside `assets/`.
     */
    assetRoot?: string;
    sourceCss: string;
    destinationAssetDir: string;
    /**
     * Public URL prefix for copied files, for example `/wp-content/blocks/acme/assets/`.
     * Defaults to `./<basename(destinationAssetDir)>/`.
     */
    assetUrlPrefix?: string;
    /**
     * Legacy switch retained for source compatibility. It is deliberately insufficient on its own:
     * fontLicenses must identify the exact local file and ownership decision.
     */
    /** @deprecated Use fontLicenses with a reference, source, hash, ownership, and license. */
    allowFontLicense?: boolean;
    /** Explicit, reference-bound local font decisions. Remote/data fonts can never be authorized. */
    fontLicenses?: readonly FontLicenseDecision[];
}
interface RewriteCssAssetsResult {
    /** CSS with only successfully copied local references rewritten. */
    css: string;
    /** Alias for consumers that prefer an explicit result name. */
    rewrittenCss: string;
    /** A complete, one-entry-per-`url()` asset ledger. */
    assets: CssAssetLedgerEntry[];
    /** Alias for `assets`, to make the accounting purpose clear at call sites. */
    ledger: CssAssetLedgerEntry[];
    /** Font references that were not copied because no complete licensed-file decision was supplied. */
    warnings: FontAssetWarning[];
}
/**
 * Find literal CSS `url(...)` functions without treating strings and comments as references.
 * This is a lexer, not a CSS formatter: the original CSS is retained byte-for-byte unless a local
 * asset is successfully copied and needs its URL rewritten.
 */
declare function scanCssUrlReferences$1(sourceCss: string, sourcePath?: string, stylesheet?: CssStylesheet): CssUrlReference[];
/**
 * Pure classification for a CSS reference. Local files remain `unresolved` here because copying
 * is intentionally the responsibility of `rewriteCssAssets`; nothing is fetched or written by
 * classification alone.
 */
declare function classifyCssUrlReference$1(reference: CssUrlReference, options: Pick<RewriteCssAssetsOptions, 'sourcePath' | 'assetRoot' | 'allowFontLicense' | 'fontLicenses'>): CssAssetLedgerEntry;
/**
 * Copy safe local URL targets to `destinationAssetDir` and replace exactly those `url(...)`
 * tokens in the returned CSS. HTTP(S) and protocol-relative URLs are deliberately never fetched;
 * they are ledgered as external and left as authored.
 */
declare function rewriteCssAssets$1(options: RewriteCssAssetsOptions): Promise<RewriteCssAssetsResult>;

interface GeneratedAssetFile {
    path: string;
    kind: 'asset';
    /** Image/font is kept separate from the manifest's generic file kind for the generator seam. */
    assetKind?: Exclude<CssAssetKind, 'asset'> | 'image';
    content: Buffer;
    hash: string;
    operation: 'create' | 'replace';
}

/**
 * The owned source-template contract. Changing it changes every generated package and must be an
 * intentional, reviewed release decision.
 */
declare const REGISTERED_BLOCK_TEMPLATE_VERSION$1: "0.9-static-v11";
type GeneratedSourceKind = 'json' | 'javascript' | 'scss' | 'php' | 'text';
declare const GENERATED_REGISTERED_BLOCK_PATHS$1: readonly ["block.json", "index.js", "edit.js", "save.js", "style.scss", "editor.scss", "block.php"];
declare const ASSET_URL_MODULE: "asset-urls.mjs";
declare const FONT_LICENSES_FILE: "font-licenses.txt";
type GeneratedSourcePath = typeof GENERATED_REGISTERED_BLOCK_PATHS$1[number] | typeof ASSET_URL_MODULE | typeof FONT_LICENSES_FILE;
interface GeneratedSourceFile {
    path: GeneratedSourcePath;
    kind: GeneratedSourceKind;
    content: string;
    hash: string;
    operation: AuthoringFileOperation;
}
interface GeneratedSourceManifestEntry {
    path: string;
    kind: GeneratedSourceKind | 'asset';
    contentHash: string;
    operation: AuthoringFileOperation;
    templateVersion: typeof REGISTERED_BLOCK_TEMPLATE_VERSION$1;
    sourcePlanHash: string;
}
interface GeneratedSourceManifest {
    templateVersion: typeof REGISTERED_BLOCK_TEMPLATE_VERSION$1;
    sourcePlanHash: string;
    /** Pin used for this headless capability check; it is not evidence for every WordPress site. */
    registry: AuthoringRegistryIdentity;
    files: GeneratedSourceManifestEntry[];
}
interface GeneratedRegisteredBlock {
    assets: GeneratedAssetFile[];
    /** The exact native template emitted into edit.js, also used by runtime proof. */
    template: TemplateNode[];
    templateVersion: typeof REGISTERED_BLOCK_TEMPLATE_VERSION$1;
    sourcePlanHash: string;
    files: GeneratedSourceFile[];
    manifest: GeneratedSourceManifest;
}
declare class AuthoringGenerationError$1 extends Error {
    readonly reason: string;
    readonly source: {
        path: string;
    };
    constructor(reason: string, sourcePath: string);
}
type TemplateNode = [string, Record<string, JsonValue>, TemplateNode[]?];
/**
 * Compile a confirmed declarative plan into the static source files a WordPress block build
 * expects. This intentionally does not call convert/finalize: that path handles post content,
 * while this one has a stricter code-generation boundary and its own parsers.
 */
interface RegisteredBlockOutputPlan {
    files: ReadonlyArray<{
        path: string;
        operation: AuthoringFileOperation;
    }>;
}
/**
 * Derive the exact output map from a reviewed plan without materializing generated source.
 * Preview uses this to bind its destination fingerprint before confirmation.
 */
declare function planRegisteredBlockOutput$1(input: AuthoringPlan$1): RegisteredBlockOutputPlan;
/**
 * Compile a confirmed declarative plan into the static source files a WordPress block build
 * expects. This intentionally does not call convert/finalize: that path handles post content,
 * while this one has a stricter code-generation boundary and its own parsers.
 */
declare function compileRegisteredBlock$1(input: AuthoringPlan$1): GeneratedRegisteredBlock;
/** Typed JSON emitter for the API-v3 metadata document. */
declare function emitBlockJson$1(plan: Pick<AuthoringPlan$1, 'target'>, allowedBlocks?: string[]): string;
/** Typed JavaScript emitter. The client registers using metadata, never a generated duplicate. */
declare function emitIndexJs$1(): string;
/** Typed JSX emitter for a static InnerBlocks editor surface. */
declare function emitEditJs$1(template: TemplateNode[], allowedBlocks: string[], lock: AuthoringPlan$1['locking']['mode'], assets?: readonly GeneratedAssetFile[]): string;
/** Typed JSX emitter for static saved markup: native inner blocks own all planned content. */
declare function emitSaveJs$1(): string;
/**
 * Render the versioned, root-owned style subset from declarative plan outcomes.
 *
 * Native outcomes belong to the native blocks in the structure and dropped outcomes deliberately
 * produce no CSS. Token values are derived as WordPress preset references; scoped CSS outcomes
 * can only use an allowlisted declaration and a value that cannot introduce CSS structure.
 */
declare function emitScss$1(outcomes: readonly AuthoringStyleOutcome[], rootClass: string, unconstrainedRoot?: boolean): string;
/** Typed PHP emitter. It registers the package directory, letting WordPress load block.json metadata. */
declare function emitPhp$1(): string;
/** Parse every generated source type before any caller can write it to disk. */
declare function validateGeneratedSources$1(files: readonly GeneratedSourceFile[]): void;
/** Validate metadata with the pinned WordPress API-v3 JSON schema through AJV, never a Zod subset. */
declare function validateBlockMetadata$1(metadata: unknown): void;

interface Declaration {
    /** Lowercased longhand property name. */
    property: string;
    /** Trimmed value, `!important` removed. */
    value: string;
    /** The shorthand this was expanded from, when it was. Reported so warnings name what the author wrote. */
    shorthand?: string;
    /** Whether the author marked it `!important`. Drives last-wins precedence, then discarded. */
    important?: boolean;
    /**
     * Where it was authored — a class selector like `.hero` for a `<style>` rule, or undefined for an
     * inline `style` attribute. Carried so a warning names the rule the author must fix, not just the
     * element the rule landed on (principle 6).
     */
    origin?: string;
    /**
     * Index of the originating rule within the stylesheet. Two rules can share a selector
     * (`.hero{…} .other{…} .hero{…}`), and the sidecar must keep them as separate rules in their
     * original positions — collapsing them onto the first occurrence reverses the author's cascade.
     */
    originIndex?: number;
    /**
     * Stable stylesheet-rule identity used internally by registered-block authoring. Unlike the
     * selector text, it distinguishes repeated selectors and the same selector inside a conditional
     * at-rule from its top-level counterpart.
     */
    originId?: string;
}

/**
 * Every authored declaration ends in exactly one of these. The three-way split is the point: a
 * report that warns about `display:flex` on a div that correctly became columns teaches the user
 * to ignore the report, and an ignored report is silent degradation wearing a hat.
 */
type StyleOutcome = 'mapped' | 'consumed' | 'dropped' | 'overridden';
interface StyleLedgerEntry {
    property: string;
    value: string;
    outcome: StyleOutcome;
    /** The class rule it was authored in (`.hero`), or undefined for an inline style attribute. */
    origin?: string;
    /** Whether it was authored `!important` — carried so the sidecar can preserve the priority. */
    important?: boolean;
    /** Position of the originating stylesheet rule, so the sidecar can keep rules in authored order. */
    originIndex?: number;
    /** Stable stylesheet-rule identity for authoring's exact declaration handoff. */
    originId?: string;
    /** Why it was dropped, or what it became. Phrased to point at the input. */
    reason?: string;
    /** The shorthand the author actually wrote, when this came from expanding one. */
    shorthand?: string;
    /** Where it landed, for mapped entries. */
    target?: string;
    /**
     * A fidelity deviation on an otherwise-mapped declaration — it landed, but not exactly as
     * authored. Warned like a drop, because "mapped" would overstate what happened.
     */
    deviation?: string;
    /**
     * Explicitly false when a dropped declaration cannot be rescued by the `open` rung — broken input,
     * or CSS with no single block to attach a class to. Well-formed drops are carryable by default.
     */
    carryable?: false;
}

/**
 * The proof ladder is intentionally independent from any particular runner.  A
 * runner may add evidence to a gate record, but this module owns the rules for
 * deciding whether a selected profile actually passed.
 */
/** All statuses which may be written to a receipt gate. */
declare const PROOF_GATE_STATUSES$1: readonly ["pass", "fail", "skip", "blocked", "not_applicable"];
type ProofGateStatus = (typeof PROOF_GATE_STATUSES$1)[number];
/** Backwards-friendly short aliases for consumers building receipt records. */
type GateStatus = ProofGateStatus;
/**
 * The canonical gate names used in proof receipts.  Each independent claim has
 * its own gate: for example, PHP registration cannot stand in for the REST or
 * browser registries.
 */
declare const PROOF_GATE_IDS$1: readonly ["headless_validation", "zip_installation", "plugin_activation", "php_registry", "rest_block_type", "client_registry", "environment_observation", "editor_inserter", "editor_field_editing", "editor_save", "editor_reopen", "frontend_status", "frontend_semantics", "frontend_links", "frontend_media", "frontend_assets", "frontend_runtime_errors", "php_logs", "static_deactivation_html", "static_deactivation_registration", "static_deactivation_assets", "static_deactivation_editor_controls", "pattern_overrides", "visual_regression", "accessibility_editor", "accessibility_frontend", "accessibility_manual_review"];
type ProofGateId = (typeof PROOF_GATE_IDS$1)[number];
type GateId = ProofGateId;
declare const PROOF_PROFILE_NAMES$1: readonly ["headless", "runtime", "editor", "full", "generated", "built", "editor-verified", "fidelity-checked", "pattern-verified"];
type ProofProfileName = (typeof PROOF_PROFILE_NAMES$1)[number];
type ProfileName = ProofProfileName;
/** Capability claims are narrower than the historical cumulative profiles. */
declare const PROOF_CLAIM_NAMES$1: readonly ["generated", "built", "editor-verified", "fidelity-checked", "pattern-verified"];
type ProofClaimName = (typeof PROOF_CLAIM_NAMES$1)[number];
interface ProofRequirementClaim {
    claim: ProofClaimName;
    status: 'required' | 'not_applicable' | 'blocked';
    requiredGates: readonly ProofGateId[];
    reason?: string;
}
/** The runner writes this before executing any proof adapter. */
interface ProofArtifactRequirement {
    status: 'not_requested' | 'missing' | 'invalid' | 'stale' | 'confirmed';
    declaredSha256?: string;
    observedPluginZipSha256?: string;
    capabilities?: {
        patternOverrides: boolean;
    };
}
interface ProofRequirementReport {
    profile: ProofProfileName;
    artifact: ProofArtifactRequirement;
    requiredGates: readonly ProofGateId[];
    claims: readonly ProofRequirementClaim[];
    expectedEnvironment: readonly string[];
    missingInputs: readonly string[];
}
/**
 * A single receipt assertion. Evidence is deliberately opaque here so the
 * evaluator remains usable by file, Playwright, and REST-backed runners.
 */
interface ProofGateRecord {
    /** Canonical gate id, or a documented alias accepted by `normalizeProofGateId`. */
    gate: ProofGateId | string;
    status: ProofGateStatus;
    /** Human-readable reason, especially important for skip and blocked. */
    reason?: string;
    /** Content-addressed evidence references or runner-specific evidence metadata. */
    evidence?: readonly unknown[] | Record<string, unknown>;
    startedAt?: string;
    finishedAt?: string;
    [key: string]: unknown;
}
type GateRecord = ProofGateRecord;
/** A profile is explicit about every gate needed to make its claim. */
interface ProofProfile {
    name: ProofProfileName;
    requiredGates: readonly ProofGateId[];
    /** Gates that a runner may record but which do not affect this profile. */
    optionalGates: readonly ProofGateId[];
}
type ProofGateRecords = readonly ProofGateRecord[] | Readonly<Record<string, ProofGateRecord | ProofGateStatus | undefined>>;
interface ProofGateOutcome {
    gate: ProofGateId;
    status: ProofGateStatus | 'missing';
    ok: boolean;
    record?: ProofGateRecord;
}
/** A pure, serializable result suitable for embedding in an immutable receipt. */
interface ProofProfileReport {
    profile: ProofProfileName;
    ok: boolean;
    status: 'pass' | 'fail';
    required: readonly ProofGateOutcome[];
    failedGates: readonly ProofGateOutcome[];
    missingGates: readonly ProofGateId[];
}
type ProofProfileEvaluation = ProofProfileReport;
/** Map a requested capability label to the cumulative gates that substantiate it. */
declare function proofClaimGates$1(claim: ProofClaimName): readonly ProofGateId[];
/** Return a profile after validating an untrusted profile name. */
declare function getProofProfile$1(profile: ProofProfileName): ProofProfile;
/** True only for the five statuses the receipt format permits. */
declare function isProofGateStatus$1(value: unknown): value is ProofGateStatus;
/** True only for one of the four named proof profiles. */
declare function isProofProfileName$1(value: unknown): value is ProofProfileName;
/**
 * Normalize a gate name without accepting arbitrary strings as requirements.
 * Hyphenated aliases are accepted because command-line and JSON inputs often
 * use them, while receipts retain underscore-separated canonical ids.
 */
declare function normalizeProofGateId$1(gate: string): ProofGateId | undefined;
/**
 * A safe empty set of receipt records. `skip` is intentional: it prevents an
 * accidentally unrun required gate from looking successful while still saying
 * why the profile is incomplete.
 */
declare function createDefaultProofGateRecords$1(status?: ProofGateStatus): Record<ProofGateId, ProofGateRecord>;
/**
 * Evaluate a selected profile without mutating the supplied records. A
 * required gate passes only with `pass`, except for the explicitly
 * input-inapplicable media gate. `not_applicable` is evidence, not a general
 * escape hatch for omitted proof configuration: a missing frontend URL,
 * editable-field inventory, pattern fixture, visual golden, or accessibility
 * scope must block its required gate. `fail`, `skip`, `blocked`, and a missing
 * record always fail the profile.
 */
declare function evaluateProofProfile$1(profile: ProofProfileName | ProofProfile, records: ProofGateRecords): ProofProfileReport;
/**
 * Media is the only required claim whose absence can be established from the
 * input itself. Every other profile claim needs affirmative proof.
 */
declare function canBeNotApplicable$1(gate: ProofGateId): boolean;
/** Evaluate every profile against the same receipt records. */
declare function evaluateProofProfiles$1(records: ProofGateRecords): Record<ProofProfileName, ProofProfileReport>;

/** A complete SHA-256 content address, including its algorithm identifier. */
type Sha256 = `sha256:${string}`;
/** The only values accepted by the canonical JSON encoder. */
type CanonicalJsonValue = null | boolean | number | string | CanonicalJsonValue[] | {
    [key: string]: CanonicalJsonValue;
};
/** A deliberately open receipt shape: each proof runner owns its gate payloads. */
interface ProofReceipt {
    [key: string]: unknown;
}
/** A portable reference to an immutable blob beneath the store root. */
interface ContentAddressedReference {
    /** Content address for the exact stored bytes. */
    sha256: Sha256;
    /** Number of stored bytes. */
    bytes: number;
    /** POSIX-style path relative to the caller-supplied root. */
    path: string;
    /** Declared media type; it does not participate in the content address. */
    mediaType: string;
}
/** Reference returned after storing captured evidence. */
interface EvidenceReference extends ContentAddressedReference {
    path: `evidence/sha256/${string}`;
}
/** Reference returned after writing a canonical receipt. */
interface ReceiptReference extends ContentAddressedReference {
    path: `receipts/sha256/${string}.json`;
    mediaType: 'application/json';
}
interface EvidencePutOptions {
    /** Defaults to text/plain for strings and application/octet-stream for bytes. */
    mediaType?: string;
}
interface ReceiptWriteResult extends ReceiptReference {
    /** Exact UTF-8 JSON bytes whose digest is `sha256`. */
    canonicalJson: string;
    /** True only when this call created the address; false when it deduplicated. */
    created: boolean;
}
type HashInput = string | Uint8Array | ArrayBuffer;
/**
 * Error raised if a path which ought to identify content has been modified, is a
 * non-file, or contains bytes different from those expected for its address.
 */
declare class ImmutableContentError$1 extends Error {
    constructor(message: string);
}
/**
 * Produce deterministic JSON for receipt data.
 *
 * This intentionally accepts a smaller domain than JSON.stringify: undefined,
 * functions, symbols, bigint, non-finite numbers, sparse arrays, cycles, and
 * non-plain objects are errors rather than silently changed or omitted. That
 * makes a receipt's hash a faithful representation of the supplied data.
 */
declare function canonicalJson$1(value: unknown): string;
/** SHA-256 of UTF-8 text or exact byte input, in content-address form. */
declare function sha256$1(input: HashInput): Sha256;
/** SHA-256 of the exact canonical JSON representation of a value. */
declare function hashCanonicalJson$1(value: unknown): Sha256;
/**
 * Stores arbitrary evidence below `<root>/evidence/sha256/<hex digest>`.
 * Existing content is never overwritten. A repeat write of identical bytes is
 * deduplicated; a mismatched pre-existing path is treated as tampering.
 */
declare class EvidenceStore$1 {
    readonly root: string;
    constructor(root: string);
    put(input: HashInput, options?: EvidencePutOptions): Promise<EvidenceReference>;
    /** Canonicalize an object first, then retain the exact JSON evidence bytes. */
    putJson(value: unknown): Promise<EvidenceReference>;
    /** Read evidence and verify that its bytes still match its content address. */
    read(reference: EvidenceReference | Sha256): Promise<Buffer>;
    /** Stable, relative location for an address. It does not assert that it exists. */
    pathFor(address: Sha256): string;
}
/**
 * Writes canonical receipts below `<root>/receipts/sha256/<hex digest>.json`.
 * The receipt filename and returned `sha256` are both the hash of the exact
 * canonical JSON bytes, so the address can be checked without trusting the
 * surrounding run directory.
 */
declare class ReceiptWriter$1 {
    readonly root: string;
    readonly evidence: EvidenceStore$1;
    constructor(root: string);
    write(receipt: object): Promise<ReceiptWriteResult>;
    /** Read a receipt, verifying its address before parsing its canonical JSON. */
    read(address: Sha256): Promise<ProofReceipt>;
    pathFor(address: Sha256): string;
}

interface WordPressPackagePin {
    /** Exact version resolved from the source lockfile or packed proof pin snapshot. */
    version: string;
    /** npm Subresource Integrity value resolved from the source lockfile or packed proof pin snapshot. */
    integrity: string;
}
/** Editable surfaces supplied by the generated-block compiler or a fixture. */
type ProofEditableSurface = 'richText' | 'media' | 'link' | 'altText';
interface ProofEditableField {
    path: string;
    surface: ProofEditableSurface;
    /** Exact native metadata.name; required when the inserted block contains competing fields. */
    metadataName?: string;
    /** A real, prepared Media Library selection for a media field. */
    media?: {
        id: number;
        url: string;
        alt: string;
    };
    /** A stable selector may be supplied when a block has a custom editor UI. */
    selector?: string;
    /** The value the browser proof must persist. */
    value?: string;
}
/**
 * A deliberately small, browser-observable reproduction of a generated
 * block's root layout.  This is separate from visual regression: it records
 * the editor-canvas DOM before and after the content cases that used to be
 * hidden by the extra InnerBlocks wrapper.
 */
interface ProofBrowserMatrix {
    /** The computed display mode which must belong to the generated root. */
    rootLayout: 'grid' | 'flex';
    /** Exact native blocks emitted as children of the generated root. */
    directNativeChildren: readonly string[];
    /** The block-owned family declared by the shared stylesheet. */
    fontFamily: string;
    /** Text written to and then removed from the native heading in the iframe. */
    longContent: string;
    /** Deliberately non-default native Image proportions observed at narrow width. */
    image: {
        width: string;
        height: string;
    };
    desktopViewport: {
        width: number;
        height: number;
    };
    narrowViewport: {
        width: number;
        height: number;
    };
    /**
     * Opt-in computed-style assertions for an author()-produced responsive
     * native mapping. The sibling deliberately repeats the source class outside
     * the generated root, so an omitted root prefix cannot masquerade as
     * component-local CSS.
     */
    responsive?: ProofResponsiveStyleMatrix;
}
interface ProofResponsiveStyleMatrix {
    /** Selector relative to the generated root for the native child being proved. */
    targetSelector: string;
    /** Source class repeated on an unrelated paragraph outside the generated root. */
    siblingClass: string;
    /** Keep this intentionally narrow until another computed-style claim needs evidence. */
    property: 'font-size' | 'color';
    /** A separate sibling property makes the same fixture prove scoped residual CSS. */
    siblingProperty?: 'font-size' | 'color';
    /** Controlled baseline for the external same-class sentinel. */
    siblingInlineStyle?: string;
    /** At least narrow and desktop; boundary samples may be supplied as well. */
    samples: readonly {
        label: string;
        /** Browser viewport requested before measuring the actual proof surface. */
        viewport: {
            width: number;
            height: number;
        };
        /**
         * Optional exact editor-canvas/frontend viewport. The helper adjusts the
         * top-level viewport to reach this width, then fails if WordPress's iframe
         * still cannot supply it. Use this for below/equal/above breakpoint proof.
         */
        surfaceViewport?: {
            width: number;
            height?: number;
        };
        target: string;
        sibling: string;
    }[];
}
/**
 * Focused evidence for source styles adapted to Core Button, Image, and Group
 * markup.  It deliberately names only the browser-observable relationships
 * owned by the native adapter; it is not a general layout assertion surface.
 */
interface NativeStyleAdapterMatrix {
    button: {
        /** Selector relative to the generated root for the Core Button wrapper. */
        wrapperSelector: string;
        /** Selector relative to the generated root for its interactive anchor. */
        linkSelector: string;
        /** Computed source padding which must belong to the anchor, never its wrapper. */
        linkPadding: {
            top: string;
            right: string;
            bottom: string;
            left: string;
        };
        /** The authored hover transform and colour, each observed exactly on the anchor. */
        hover: {
            transform: string;
            backgroundColor: string;
        };
        /** The authored keyboard focus outline on the anchor. */
        focusOutline: {
            style: string;
            width: string;
        };
    };
    image: {
        selector: string;
        /** Preserved intrinsic evidence represented by the native image target. */
        sourceDimensions: {
            width: string;
            height: string;
            aspectRatio: string;
        };
        alt: string;
        caption: string;
    };
    grid: {
        selector: string;
        samples: readonly {
            label: string;
            viewport: {
                width: number;
                height: number;
            };
            surfaceViewport?: {
                width: number;
                height?: number;
            };
            columns: number;
        }[];
    };
}
/** The exact per-instance map WordPress stores at core/block.attributes.content. */
type PatternOverrideContent = Record<string, Record<string, unknown>>;
interface ProofPatternInstance {
    /** Human-readable identity used only in receipts. */
    label: string;
    /** Distinct local values keyed by a child block's metadata.name. */
    content: PatternOverrideContent;
}
interface ProofPatternRequiredBinding {
    name: string;
    attribute: string;
}
interface ProofPatternNegativeBinding extends ProofPatternRequiredBinding {
    /** Value entered through the native control of a deliberately deficient pattern. */
    value: string;
    /** Canonical value which must render after the deficient edit is discarded. */
    fallback: string;
}
/**
 * Assertions which belong to a particular generated block. This deliberately
 * accepts the compiler's simple `editableFields` inventory without importing
 * an authoring implementation from another package/branch.
 */
interface ProofFixture {
    blockName: string;
    /** Plugin archive slug when it differs from the block slug. */
    pluginSlug?: string;
    /** @deprecated The runner always uses the post it creates and publishes. */
    postId?: number;
    blockTitle?: string;
    editableFields?: readonly ProofEditableField[];
    /**
     * Opt-in real-browser root-layout evidence. The helper refuses to record a
     * pass unless WordPress 7.1 rendered the generated root inside editor-canvas
     * at both declared viewport widths.
     */
    browserMatrix?: ProofBrowserMatrix;
    /**
     * A focused author()-produced responsive-style probe. Unlike browserMatrix,
     * it does not require the historical heading/image layout reproduction.
     */
    responsiveStyleMatrix?: ProofResponsiveStyleMatrix;
    /** Public author()-to-WordPress proof for the bounded native style adapters. */
    nativeStyleAdapterMatrix?: NativeStyleAdapterMatrix;
    patternOverrides?: {
        /** Exact pattern title inserted through the visible inserter. */
        title: string;
        /**
         * Canonical wp_block.post_content. It must contain only native
         * core/pattern-overrides bindings for the required child attributes.
         */
        canonicalContent: string;
        /** Two independently inserted core/block references with local values. */
        instances: readonly [ProofPatternInstance, ProofPatternInstance];
        /** A canonical-only layout/style update made through the core patterns REST route. */
        canonicalUpdate: {
            content: string;
            /** A visible marker that must reach both frontend instances. */
            marker: string;
        };
        /** Remove this one local value and verify WordPress falls back to canonical content. */
        reset: {
            instance: 0 | 1;
            name: string;
            attribute: string;
            fallback: string;
        };
        /** Required Core child bindings; omission is a failing negative, never a pass. */
        requiredBindings: readonly ProofPatternRequiredBinding[];
        /** The compiler's confirmed structural policy. */
        structuralPolicy: 'all' | 'contentOnly';
        /**
         * Required negative: the runner saves a separate deficient wp_block,
         * drives its native control, and proves its value cannot persist/render.
         */
        negative: ProofPatternNegativeBinding;
        /** Observed at runtime; never supplied by a fixture. */
        ref?: number;
        /** Exact wp_block.post_content read after WordPress saves the canonical pattern. */
        storedCanonicalContent?: string;
    };
    frontend?: {
        /** Required proof scope; navigation always uses the post published in this run. */
        url?: string;
        subtreeSelector?: string;
        expectedLinks?: readonly string[];
        expectedMedia?: readonly string[];
    };
    visual?: {
        /** Reviewed golden; the runner never changes this file. */
        expectedPath: string;
        /** A unique rendered design region; excludes unrelated theme/admin UI. */
        selector?: string;
        masks?: readonly string[];
        /** Fraction of differing pixels, from 0 to 1. */
        threshold: number;
    };
    accessibility?: {
        editorSelector?: string;
        frontendSelector?: string;
        /** A human result is recorded alongside Axe; Axe alone is not a WCAG claim. */
        manualReview: ProofGateStatus;
        /** JSON review record pinned to this exact input and plugin ZIP. A bare pass is not evidence. */
        manualReviewPath?: string;
    };
}
/** Immutable capability contract emitted for the exact archive under proof. */
interface ProofArtifactContract {
    sha256: Sha256;
    capabilities: {
        patternOverrides: boolean;
    };
}
interface ProofCommandResult {
    command: string;
    args: string[];
    cwd?: string;
    exitCode: number | null;
    stdout: string;
    stderr: string;
    phase?: string;
    durationMs?: number;
    timedOut?: boolean;
}
interface ProofCommandOptions {
    cwd?: string;
    env?: NodeJS.ProcessEnv;
    /** A bounded command phase; defaults are applied by the built-in runner. */
    timeoutMs?: number;
    /** Included in immutable command evidence and concise proof progress logs. */
    phase?: string;
}
type ProofCommandRunner = (command: string, args: readonly string[], options: ProofCommandOptions) => Promise<ProofCommandResult>;
interface ProofGateResult {
    status: ProofGateStatus;
    reason?: string;
    details?: Record<string, unknown>;
    /** Additional immutable evidence captured by an adapter. */
    evidence?: readonly EvidenceReference[];
}
interface ProofGateContext {
    profile: ProofProfileName;
    gate: ProofGateId;
    fixture?: ProofFixture;
    artifact?: ProofArtifactContract;
    pluginZip?: string;
    wpEnvConfig: string;
    environment: ProofEnvironment;
    /** Persist an adapter's raw logs, JSON, screenshot, Axe response, etc. */
    capture: (value: string | Uint8Array | ArrayBuffer | Record<string, unknown>, mediaType?: string) => Promise<EvidenceReference>;
}
/**
 * An adapter boundary for CI and consumers that have their own authenticated
 * browser harness. It makes it impossible to turn an unrun browser action
 * into a pass: omitted required gates are recorded as `blocked`.
 */
type ProofGateRunner = (context: ProofGateContext) => Promise<ProofGateResult | undefined>;
interface ProofRunOptions {
    profile?: ProofProfileName;
    /** Built, installable static-plugin archive. Runtime profiles require it. */
    pluginZip?: string;
    /** Confirmed artifact capability contract. Capability-scoped claims bind it to pluginZip. */
    artifact?: ProofArtifactContract;
    /** Generator input bytes or a path to its reviewed input. */
    input?: string | Uint8Array;
    inputPath?: string;
    /** Post/block markup for the cheap headless Gutenberg validation gate. */
    markup?: string;
    fixture?: ProofFixture;
    /** Root for immutable `evidence/sha256` and `receipts/sha256` objects. */
    outputDir?: string;
    wpEnvConfig?: string;
    /** Defaults to true. Set false only for receipt-shape tests or dry diagnosis. */
    execute?: boolean;
    /** Keep wp-env alive after a real run. The default tears it down in a finally block. */
    keepEnvironment?: boolean;
    commandRunner?: ProofCommandRunner;
    gateRunner?: ProofGateRunner;
}
interface ProofFilePin {
    path?: string;
    sha256: Sha256;
    bytes: number;
    evidence: EvidenceReference;
}
interface ProofEnvironment {
    /** Raw command observations used to populate the runtime fields below. */
    observations?: EvidenceReference;
    generator: {
        package: string;
        version: string;
        packageJson: ProofFilePin;
        /** Source package-lock.json, or the packed proof dependency pin snapshot. */
        packageLock?: ProofFilePin;
    };
    plugin: {
        zip?: ProofFilePin;
        /** WordPress plugin metadata observed after the supplied ZIP is installed. */
        slug?: string;
        name?: string;
        version?: string;
        file?: string;
    };
    input?: ProofFilePin;
    wordpress: {
        requestedVersion: '7.1';
        /** Exact `core` source read from the pinned wp-env configuration. */
        coreSource: string;
        wpEnv: string;
        wpEnvConfig: ProofFilePin;
        version: string;
        coreHash: string;
        dockerImage?: string;
    };
    php: {
        requestedVersion: string;
        version: string;
    };
    database: {
        engine: 'mysql' | 'mariadb';
        image: string;
        version: string;
    };
    theme: {
        name: string;
        version: string;
        fileHash: string;
    };
    browser: {
        engine: 'chromium';
        playwright: string;
        revision: string;
        version: string;
    };
    node: {
        version: string;
    };
    /** Exact, integrity-pinned direct @wordpress/* dependencies. */
    wordpressPackages: Record<string, WordPressPackagePin>;
}
interface ProofReceiptDocument {
    schemaVersion: 1;
    kind: 'block-runner.wordpress-proof';
    createdAt: string;
    selectedProfile: ProofProfileName;
    ok: boolean;
    environment: ProofEnvironment;
    /** Pre-run capability contract and missing-input diagnosis retained with the raw gates. */
    requirements?: ProofRequirementReport;
    gates: ProofGateRecord[];
    profile: ProofProfileReport;
}
interface ProofRunResult {
    ok: boolean;
    profile: ProofProfileReport;
    receipt: ProofReceiptDocument;
    receiptReference: ReceiptReference;
}
/**
 * Run one cumulative proof profile and write a content-addressed receipt.
 *
 * `headless` runs entirely in Node. Higher profiles boot a pinned wp-env
 * Docker/MySQL environment, install the exact ZIP, then delegate browser work
 * to the bundled WordPress-Playwright helper. Any unavailable prerequisite is
 * a `blocked` gate, never a false green result.
 */
declare function runProof$1(options: ProofRunOptions): Promise<ProofRunResult>;
/**
 * Build the requirement report before a runner invokes Docker, Playwright, or
 * a caller adapter. The original named profiles remain byte-for-byte in scope;
 * only capability-scoped profiles need an immutable artifact contract.
 */
declare function reportProofRequirements$1(profile: ProofProfileName, artifact: ProofArtifactContract | undefined, observedPluginZip: Sha256 | undefined, fixture?: ProofFixture): ProofRequirementReport;

type CommandName = 'validate' | 'fix' | 'convert' | 'assemble' | 'author';
type ReportStatus = 'valid' | 'invalid' | 'warning';
interface SourceLocation {
    path?: string;
    selector?: string;
    htmlLine?: number;
    htmlColumn?: number;
    offset?: number;
}
/**
 * A selector condition rewritten to a transport class before native conversion removes arbitrary
 * source IDs/attributes. It is internal to the registered-block authoring handoff.
 */
interface SourceSelectorDependency {
    markerClass: string;
    kind: 'id' | 'attribute';
    /** Decoded id value, or the complete attribute selector such as `[data-state="open"]`. */
    value: string;
}
interface ReportItem {
    block?: string;
    status: ReportStatus;
    reason: string;
    source?: SourceLocation;
    rule?: string;
    details?: unknown;
    /** Stable machine-readable failure category when authoring cannot map native markup. */
    code?: string;
}
interface ReportSummary {
    blocks: number;
    valid: number;
    invalid: number;
    warnings: number;
}
interface BlockRunnerReport {
    ok: boolean;
    command: CommandName;
    summary: ReportSummary;
    items: ReportItem[];
    /** Exact source identity for the registered-block HTML authoring pass, when available. */
    source?: AuthoringSource;
    /**
     * Deterministic observations made at the input edge. This is deliberately available even when
     * the optional HTML-to-block rules proposal cannot represent the source.
     */
    evidence?: AuthorSourceEvidence;
    /** Advisory guidance only; never affects `ok` or summary counts. */
    hint?: string;
    output?: string;
    /**
     * CSS the block model cannot express, emitted by the `open` styling rung. Present only when that
     * rung rescued something. The caller must ship this alongside the content — the rung is only
     * honest if it does, which is why `open` requires an explicit sink.
     */
    sidecarCss?: string;
    /**
     * Every asset observed while authoring a registered block.  This is deliberately separate from
     * Gutenberg media IDs: static block assets do not need (and must never invent) media-library
     * records.
     */
    assets?: AssetLedgerEntry[];
    /** One terminal disposition for every declaration in an authored stylesheet graph. */
    styleLedger?: AuthoredStyleLedgerEntry[];
    /** Files that make up an authored registered block, keyed by their package-relative path. */
    package?: GeneratedBlockPackage$1;
}
/** A source element observed without assigning it a Gutenberg meaning. */
interface AuthorSourceElement {
    tag: string;
    attributes: Record<string, string>;
    source?: SourceLocation;
    /** Stable only for this exact source SHA-256 and parser range. */
    sourceRef?: string;
}
interface AuthoringProposalNode {
    id: string;
    block: string;
    sourceRef?: string;
    attributes?: Record<string, JsonValue>;
    lock?: AuthoringNodeLock;
    children?: AuthoringProposalNode[];
}
interface AuthoringProposalDecision {
    action: 'add' | 'replace' | 'omit';
    sourceRef: string;
    node?: string;
    attribute?: string;
    value?: JsonValue;
    reason: string;
}
/** Model-facing design choices. Source/asset/style bookkeeping is deliberately absent. */
interface AuthoringProposal {
    structure: AuthoringProposalNode[];
    fields?: AuthoringField[];
    locking?: AuthoringLocking;
    allowedBlocks?: string[];
    pattern?: AuthoringPattern;
    sourceDecisions?: AuthoringProposalDecision[];
}
/**
 * Evidence separated from a proposed native tree. Consumers may use it to construct a plan, but
 * must carry its source and coverage records into that plan before compiling it.
 */
interface AuthorSourceEvidence {
    source: AuthoringSource;
    structure: AuthorSourceElement[];
    dependencies: Array<{
        kind: 'stylesheet' | 'tailwind-build';
        reference: string;
        source?: SourceLocation;
    }>;
    /** Input-edge diagnostics. They never instruct a caller to rewrite otherwise safe markup. */
    diagnostics: ReportItem[];
    /** Present once CSS/assets have been scanned, including unresolved dispositions. */
    coverage?: AuthoringCoverage;
    /** Deterministic plan inputs, available even when the advisory native structure needs work. */
    transport?: {
        styles: AuthoringStyles;
        assets: AuthoringAsset[];
        warnings: string[];
    };
}
type AuthoredStyleOutcome = 'native' | 'preset' | 'literal' | 'scoped-css' | 'warned' | 'blocked';
interface AuthoredStyleLedgerEntry {
    /** Scanner identity; unlike property/value this cannot collide with a repeated declaration. */
    declarationId?: string;
    ruleId?: string;
    property: string;
    value: string;
    outcome: AuthoredStyleOutcome;
    reason?: string;
    atRules: string[];
    source?: SourceLocation;
    /** Component-local selector emitted after source selector dependency transport. */
    transportSelector?: string;
    /** Native-node evidence for a conservatively lifted WordPress responsive declaration. */
    node?: string;
    responsive?: 'mobile' | 'tablet';
    /** Compiler-owned native adapter destinations for this original declaration. */
    nativeTargets?: Array<{
        node: string;
        role: 'button-link' | 'button-wrapper-reset' | 'image' | 'caption' | 'grid-container';
        selector: string;
        intrinsic?: {
            width: string;
            height: string;
            aspectRatio: string;
        };
    }>;
}
/** The terminal disposition of a source asset. */
type AssetOutcome = 'prepared' | 'copied' | 'uploaded' | 'reused' | 'external' | 'unresolved' | 'blocked';
interface AssetLedgerEntry {
    /** The source spelling, before any package-relative rewrite. */
    reference: string;
    /** The package-relative replacement, where a local asset was copied. */
    rewritten?: string;
    /** How the asset was encountered. */
    kind: 'image' | 'font' | 'stylesheet' | 'media' | 'other';
    outcome: AssetOutcome;
    reason?: string;
    source?: SourceLocation;
}
/** The materialized inputs handed to the project's pinned Tailwind compiler. */
interface TailwindCompilerInput {
    /** Each declared entry after Block Runner has read it from the supplied style graph. */
    cssEntries: ReadonlyArray<{
        path: string;
        css: string;
    }>;
    /** Resolved local imports supplied as part of the graph. */
    imports: ReadonlyArray<{
        path: string;
        css: string;
    }>;
    directives: readonly string[];
    sources: readonly string[];
    safelist: readonly string[];
    plugins: readonly string[];
    environment: Readonly<Record<string, string | number | boolean | null | undefined>>;
    browserTarget: string | readonly string[];
}
/**
 * A compiler deliberately comes from the calling project, where its Tailwind version and plugins
 * are pinned.  Block Runner invokes it during authoring and never ships it with the generated
 * block.  The name/version fields make that provenance visible in configuration and reports.
 */
interface TailwindCompiler {
    name: string;
    version: string;
    compile(input: TailwindCompilerInput): string | Promise<string>;
}
/**
 * Inputs required to make a Tailwind fidelity claim.  Empty arrays/objects are meaningful: they
 * say that a project has explicitly supplied no plugins/safelist/etc.  An omitted field is not
 * equivalent to an empty one and is reported as missing.
 */
interface TailwindBuildGraph {
    cssEntries?: readonly string[];
    imports?: readonly string[];
    directives?: readonly string[];
    sources?: readonly string[];
    safelist?: readonly string[];
    plugins?: readonly string[];
    environment?: Readonly<Record<string, string | number | boolean | null | undefined>>;
    browserTarget?: string | readonly string[];
    /** The pinned compiler that must produce the stylesheet used for authoring. */
    compiler?: TailwindCompiler;
}
interface AuthorStyleConfig {
    /**
     * Declares how the stylesheet was produced. CSS provenance cannot be recovered from compiled
     * declarations, so this is required whenever authoring receives non-empty stylesheet input.
     */
    mode?: 'css' | 'tailwind';
    /** Actual compiled CSS. In Tailwind mode it must match the pinned compiler output. */
    css?: string;
    /** Required for Tailwind source or runtime output; its compiler is run during authoring. */
    tailwind?: TailwindBuildGraph;
    /** Explicitly supplied editor-only affordances. Parity CSS is always emitted through `style`. */
    editorCss?: string;
    /** Reference-bound local WOFF/WOFF2 decisions; a boolean cannot establish redistribution rights. */
    fontLicenses?: readonly FontLicenseDecision[];
    /** Optional destination-approved fallback stack for fonts which cannot be redistributed. */
    fallbackStack?: string;
    /**
     * Opt in to containing otherwise-global foundation rules inside the generated block. This does
     * not claim document-wide equivalence; unscoped authoring continues to reject them by default.
     */
    foundation?: 'component';
    /** Target facts used for ownership decisions; copied into the hash-bound plan coverage. */
    context?: {
        theme?: {
            slug?: string;
            version?: string;
            settings?: Record<string, unknown>;
        };
        viewports?: Partial<Record<'mobile' | 'tablet', {
            min?: string;
            max?: string;
        }>>;
    };
}
interface AuthorConfig {
    /** Namespace/slug, for example `acme/hero`. Must name exactly one registered block. */
    name?: string;
    title?: string;
    category?: string;
    /** Optional known supports of the generated block. Values are never assumed from a slug. */
    supports?: Record<string, unknown>;
    /** Proposed native structure policy, exposed in the returned canonical plan. */
    locking?: AuthoringLocking;
    styles?: AuthorStyleConfig;
}
interface GeneratedBlockPackage$1 {
    name: string;
    rootSelector: string;
    files: Record<string, string>;
    /** Review or modify this plan through author preview/write before publishing source. */
    canonicalPlan?: AuthoringPlan$1;
    manifest?: GeneratedSourceManifest;
    /** Hash-bound local files prepared without writing; executable source remains separate. */
    assets?: Array<{
        source: string;
        path: string;
        sha256: string;
    }>;
}
type ResolverKind = 'noop' | 'map' | 'wpcli' | 'rest';
interface MediaConfig {
    resolver?: ResolverKind;
    mapFile?: string;
    map?: Record<string, MediaMapEntry>;
    allowRemote?: boolean;
    reuse?: boolean;
    wpUrl?: string;
    wpUser?: string;
    wpAppPassword?: string;
}
interface MediaMapEntry {
    id?: number | null;
    url?: string;
}
interface MediaResult {
    url: string;
    id: number | null;
    resolved: boolean;
    reason?: string;
}
interface MediaResolveInput {
    urlOrPath: string;
    source?: SourceLocation;
    kind: 'cover' | 'image';
}
interface MediaResolver {
    kind: ResolverKind;
    resolve(input: MediaResolveInput): Promise<MediaResult>;
}
type TokenMatchMode = 'exact' | 'nearest';
type TokenResolverKind = 'noop' | 'file' | 'wpcli' | 'rest' | 'context';
interface TokenConfig {
    colors?: Record<string, string>;
    fonts?: Record<string, string>;
    fontSizes?: Record<string, string>;
    spacing?: string[] | Record<string, string>;
    match?: TokenMatchMode;
    resolver?: TokenResolverKind;
    themeJson?: string;
    context?: string;
}
interface ResolvedTokens {
    colors: Record<string, string>;
    fonts: Record<string, string>;
    fontSizes: Record<string, string>;
    spacing: Record<string, string>;
}
interface TokenResolver {
    kind: TokenResolverKind;
    resolve(): Promise<ResolvedTokens>;
}
interface RuleConfig {
    disabledDefaults?: string[];
    order?: string[];
    custom?: unknown[];
}
/**
 * The styling ceiling, from safest (cleanest, most editable) to most faithful. Per element the
 * converter uses the strictest rung that still captures the design, never exceeding this ceiling.
 *
 * - `strict` — the theme's vocabulary only; off-system values are dropped and reported.
 * - `relaxed` — keep exact values on the block's `style` attribute. The default.
 * - `open` — also keep CSS no block attribute can express, as sidecar CSS the caller must ship.
 *
 * A `source` rung (keep the original markup as Custom HTML) is designed but not built, and is
 * deliberately absent here rather than exported as an option every runtime path rejects.
 */
type StylingRung = 'strict' | 'relaxed' | 'open';
interface BlockRunnerConfig {
    strict?: boolean;
    styling?: StylingRung;
    media?: MediaConfig;
    tokens?: TokenConfig;
    rules?: RuleConfig | unknown[];
    /** Registered-block authoring options. Kept separate from the legacy post-content converter. */
    author?: AuthorConfig;
}
interface CommonOptions {
    configPath?: string;
    sourcePath?: string;
    strict?: boolean;
    explain?: boolean;
    resolver?: ResolverKind;
    wpUrl?: string;
    wpUser?: string;
    wpAppPassword?: string;
    tokenResolver?: TokenResolverKind;
    themeJson?: string;
    tokenMatch?: TokenMatchMode;
    context?: string;
    styling?: StylingRung;
}
interface ConvertOptions extends CommonOptions {
    config?: BlockRunnerConfig;
    /**
     * Internal authoring hook: retain only source classes referenced by generated scoped CSS on the
     * native block that claimed the source element. Undefined preserves legacy conversion output.
     */
    preserveSourceClasses?: readonly string[];
    /** Internal authoring handoff for IDs/attributes referenced by the generated scoped CSS. */
    preserveSourceSelectorDependencies?: readonly SourceSelectorDependency[];
    /**
     * Source class declarations retained by the authored stylesheet. They are excluded from the
     * native styling pass so one declaration never lands both as scoped CSS and as a block style.
     */
    suppressSourceDeclarations?: readonly string[];
    /** Internal authoring boundary for asset forms a native Core block cannot faithfully retain. */
    preserveAssetForms?: boolean;
    /** Internal observer used by registered-block authoring to account for inline declarations. */
    styleLedgerObserver?: (entries: readonly StyleLedgerEntry[], source: SourceLocation, block?: string) => void;
}
interface AuthorOptions extends ConvertOptions {
    /** Directory to write the generated package. Omit to inspect `report.package` without writing. */
    outDir?: string;
    /**
     * Explicit boundary for local assets referenced by authored markup. Defaults to the directory
     * containing `sourcePath`; supply a non-empty root only to authorize its descendants outside
     * that directory.
     */
    assetRoot?: string;
    /** Per-run author settings, which override `config.author`. */
    author?: AuthorConfig;
    /**
     * A caller-authored native proposal. It is validated by the same registered-block compiler as a
     * rules proposal and must retain the exact source/coverage evidence observed in this run.
     */
    plan?: AuthoringPlan$1;
    /** Declarative design proposal; Block Runner derives the canonical ledgers and warnings. */
    proposal?: AuthoringProposal;
}
interface AssembleOptions extends CommonOptions {
    config?: BlockRunnerConfig;
}
interface ValidateOptions extends CommonOptions {
    config?: BlockRunnerConfig;
}
interface CanonicalizeOptions extends CommonOptions {
    config?: BlockRunnerConfig;
}
/**
 * A deliberately permissive block-intent node. The small field set gives producers a stable
 * envelope while `attrs` passes block-specific attributes through to Gutenberg. Unknown
 * attribute keys are intentionally accepted and left for the registered block type to sanitize.
 */
interface IntentNode {
    block: string;
    text?: string;
    url?: string;
    alt?: string;
    level?: number;
    citation?: string;
    items?: string[];
    rows?: string[][];
    attrs?: Record<string, unknown>;
    children?: IntentNode[];
}
interface IntentTree {
    blocks: IntentNode[];
}
/**
 * The lock applied to the one InnerBlocks area a generated block owns.
 *
 * `false` is intentional rather than an omitted value: it prevents an inherited template lock
 * from leaking into an otherwise editable generated block.
 */
type InnerBlocksLock = false | 'insert' | 'all' | 'contentOnly';
/** Alias for callers that use the WordPress `templateLock` terminology. */
type TemplateLock = InnerBlocksLock;
/**
 * Semantic roles used by the registered-block authoring path.  Roles are deliberately about the
 * editor surface, not the source HTML tag.  For example, a visual eyebrow is still a paragraph
 * unless it has document-outline meaning and should be a heading.
 */
type AuthoringRole = 'wrapper' | 'group' | 'columns' | 'column' | 'cover' | 'heading' | 'paragraph' | 'image' | 'list' | 'list-item' | 'buttons' | 'button' | 'quote' | 'custom';
/**
 * A typed description of one node in a generated registered block.
 *
 * `path` is a producer-owned stable identifier, not an array index invented while emitting
 * source. It lets previews, review UIs, and diagnostics point at exactly the same authoring
 * decision after a template has been compiled. Ordinary values intentionally live on the native
 * child (`content`, `url`, `alt`, and so on), never on the wrapper block.
 */
interface AuthoringNode {
    /** A stable, unique path within the plan, e.g. `hero.content.title`. */
    path: string;
    /** The editor-facing semantic role. */
    role: AuthoringRole;
    /**
     * Explicitly select a block implementation. This is required for `custom`, optional for native
     * roles (where the compiler supplies the matching core block).
     */
    block?: string;
    /** Initial Gutenberg attributes for this child block. */
    attributes?: Record<string, unknown>;
    /** Initial rich-text value for heading, paragraph, list item, button, or a quote's generated paragraph child. */
    content?: string;
    /** Initial image or button URL. */
    url?: string;
    /** Initial image alternative text. */
    alt?: string;
    /** Initial heading level. */
    level?: number;
    /** Nested native block template. */
    children?: AuthoringNode[];
    /** Enable native pattern overrides for supported content fields. */
    patternOverrides?: boolean;
    /**
     * A custom child that needs its own InnerBlocks region is allowed only with an explicit reason.
     * This keeps the generated wrapper at exactly one InnerBlocks region by default.
     */
    justification?: string;
    /** Whether this custom child requires a separately implemented InnerBlocks region. */
    requiresOwnInnerBlocks?: boolean;
}
/** A generated package is one custom wrapper around this native child template. */
interface AuthoringPlan {
    /** Fully-qualified registered block name, such as `acme/hero`. */
    name: string;
    title: string;
    description?: string;
    category?: string;
    icon?: string;
    textdomain?: string;
    /** The semantic wrapper. Its children are the direct InnerBlocks children. */
    root: AuthoringNode;
    /** Default: `false`, so a post or pattern lock is not inherited accidentally. */
    templateLock?: InnerBlocksLock;
    /**
     * Optional explicit direct-child allowlist. When absent it is inferred only from
     * `root.children`; nested children do not leak into this list.
     */
    allowedBlocks?: string[];
}
/** A concrete native editor field rendered by a child block. */
interface AuthoringEditableField {
    /** Stable plan path of the node that owns this surface. */
    path: string;
    role: AuthoringRole;
    block: string;
    attribute: string;
    /** The native WordPress editor surface that owns the field. */
    surface: 'richText' | 'media' | 'link' | 'altText';
    /** Stable native pattern override name. */
    overrideName?: string;
}
interface AuthoringDiagnostic {
    level: 'warning' | 'error';
    code: 'duplicate-path' | 'missing-path' | 'invalid-root' | 'unsupported-role' | 'unsupported-pattern-override' | 'duplicate-override-name' | 'custom-child-justification-required' | 'multiple-innerblocks-regions' | 'gutenberg-76794';
    message: string;
    path?: string;
}
/** Gutenberg's `[ name, attributes, children? ]` InnerBlocks template tuple. */
type AuthoringTemplate = Array<[string, Record<string, unknown>, AuthoringTemplate?]>;
/** The deterministic source package emitted from an AuthoringPlan. */
interface CompiledAuthoringBlock {
    /** The actual versioned plan used by the shared source compiler and CLI confirmation flow. */
    canonicalPlan?: AuthoringPlan$1;
    files: Record<string, string>;
    template: AuthoringTemplate;
    allowedBlocks: string[];
    templateLock: InnerBlocksLock;
    editableFields: AuthoringEditableField[];
    diagnostics: AuthoringDiagnostic[];
}
type WpBlock = {
    name: string;
    attributes: Record<string, unknown>;
    innerBlocks: WpBlock[];
    originalContent?: string;
    isValid?: boolean;
    validationIssues?: unknown[];
    __blockRunnerSource?: SourceLocation;
};
interface RuleMatch {
    matched: boolean;
    reason?: string;
}
interface RuleContext {
    wp: WpModules;
    config: BlockRunnerConfig;
    rules: Rule[];
    sourcePath?: string;
    explain: boolean;
    cssBackgrounds: Map<string, string>;
    /**
     * Single-class `<style>` rules in document order. Rules that need an element's *effective* CSS
     * should resolve it from these plus the inline attribute, never from either alone.
     */
    cssClassRules: Array<{
        className: string;
        declarations: Declaration[];
        problems: string[];
    }>;
    /** Preserve asset-bearing source markup as Custom HTML when a native block would drop it. */
    preserveAssetForms?: boolean;
    /**
     * Carry an element's inline CSS onto the block a rule just claimed. Called by the walker for
     * every claimed node; rules never need to invoke it.
     */
    applyStyles: (node: Node, blocks: WpBlock[]) => void;
    /**
     * Account for inline CSS on elements inside a block's rich text. Those descendants never pass
     * through the walker, so without this their style attributes reach the output unledgered.
     */
    noteRichTextStyles: (node: Node, block?: string, rule?: string) => void;
    warn: (reason: string, node: Node, block?: string, rule?: string, details?: unknown) => void;
    explainRule: (node: Node, rule: string, reason: string, details?: unknown) => void;
    sourceFor: (node: Node) => SourceLocation;
    recurse: (node: Node, skip?: Set<Node>) => Promise<WpBlock[]>;
    text: (node: Node) => string;
    html: (node: Element) => string;
}
interface Rule {
    id: string;
    match: (node: Element, context: RuleContext) => boolean | RuleMatch;
    emit: (node: Element, context: RuleContext) => Promise<WpBlock | WpBlock[] | null>;
}
interface WpModules {
    createBlock: (name: string, attributes?: Record<string, unknown>, innerBlocks?: WpBlock[]) => WpBlock;
    parse: (markup: string, options?: Record<string, unknown>) => WpBlock[];
    serialize: (blocks: WpBlock[] | WpBlock) => string;
    validateBlock: (block: WpBlock) => [boolean, unknown[]?];
    getBlockType: (name: string) => unknown;
    registerBlockType: (nameOrMetadata: string | Record<string, unknown>, settings?: Record<string, unknown>) => unknown;
    unregisterBlockType: (name: string) => unknown;
}

declare function canonicalize$1(markup: string, options?: CanonicalizeOptions): Promise<BlockRunnerReport>;

declare function validate$1(markup: string, options?: ValidateOptions): Promise<BlockRunnerReport>;

declare function convert$1(input: string, options?: ConvertOptions): Promise<BlockRunnerReport>;

/**
 * Produce the small, static source package for one registered block.
 *
 * This is deliberately an authoring path rather than a variation on `convert`: conversion emits
 * post content, while this function creates a block root which owns its CSS/assets.  It accepts
 * plain CSS directly, or Tailwind only through the caller's pinned compiler. It never guesses
 * utility classes, downloads a remote asset, or manufactures a media ID.
 */
declare function author$1(input: string, options?: AuthorOptions): Promise<BlockRunnerReport>;
/**
 * Read source facts without applying the rules engine. Locations refer to the original HTML and
 * unknown elements are intentionally recorded rather than classified as invalid markup.
 */
declare function collectSourceEvidence$1(input: string, source?: NonNullable<BlockRunnerReport['source']>, sourcePath?: string): AuthorSourceEvidence;

declare function extractIntent$1(out: string): IntentTree;
/**
 * Assemble an intent tree into registered Gutenberg block objects. Every node is created through
 * `createBlock`; this path never authors or injects inner HTML.
 */
declare function assemble$1(nodes: IntentNode[]): Promise<WpBlock[]>;
/**
 * Consume raw intent JSON, assemble a native block tree, and run the shared media/token/gate tail.
 */
declare function realize$1(rawIntent: string, options?: AssembleOptions): Promise<BlockRunnerReport>;

/**
 * @deprecated This accepts the pre-confirmation semantic adapter. Adapted output is exposed as
 * `canonicalPlan`; preview and write that `AuthoringPlan` with `compileRegisteredBlock`.
 *
 * Compile a reviewed authoring plan into a deliberately small registered-block source package.
 *
 * The generated wrapper has no content attributes. Its complete editable state is the native
 * InnerBlocks template, which means WordPress owns the text, image, list, and button editor
 * surfaces and serializes them normally.
 */
declare function compileAuthoringPlan$1(plan: AuthoringPlan): CompiledAuthoringBlock;

interface SiteContextOptions {
    wpUrl?: string;
    wpPath?: string;
    ssh?: string;
    wpBinary?: string;
    strict?: boolean;
}
/**
 * Collect a site.context.json manifest via wesper (WP-CLI collector).
 * Block Runner exposes the WP-CLI path; Wesper also offers REST collection directly.
 */
declare function collectSiteContext$1(options: SiteContextOptions): Promise<string>;

/** A read-only representation of the filesystem state relevant to a plan. */
interface DestinationInspection {
    directory: string;
    fingerprint: string;
    entries: ReadonlyArray<DestinationEntry>;
}
/** The destination facts a preview binds into its write confirmation. */
interface AuthoringDestinationApproval {
    directory: string;
    fingerprint: string;
}
interface DestinationEntry {
    path: string;
    kind: 'directory' | 'file' | 'missing';
    identity?: FileIdentity;
}
interface FileIdentity {
    dev: string;
    ino: string;
    mode: number;
    size: string;
    mtimeNs: string;
    ctimeNs: string;
    sha256?: string;
}
/** One target in the durable, bounded record retained after interrupted publication. */
interface PublicationRecoveryEntry$1 {
    /** Package-relative path, never a temporary staging path. */
    path: string;
    /** Hash of the approved file before replacement, when this was a replacement. */
    beforeHash?: string;
    /** Hash of the fully staged bytes that were approved for this target. */
    afterHash: string;
    /** Exact approved bytes from before a replacement, retained for recovery/audit. */
    beforeContent?: Buffer;
}
/**
 * A publication never spans filesystems atomically. This record identifies exactly which target
 * publications happened, which staged targets remain, and the original bytes for replacements.
 */
interface PublicationRecovery$1 {
    directory: string;
    completed: ReadonlyArray<PublicationRecoveryEntry$1>;
    pending: ReadonlyArray<PublicationRecoveryEntry$1>;
    replacements: ReadonlyArray<PublicationRecoveryEntry$1>;
    /** The private, same-directory journal retained for a process-independent retry. */
    recordPath?: string;
}
interface AuthoringPublicationOptions {
    /** Test-only deterministic fault injection, counted immediately after target publication. */
    failAfterPublishStep?: number;
    /** Invoked after each target has been published and durably recorded as completed. */
    onPublished?: (entry: PublicationRecoveryEntry$1, recovery: PublicationRecovery$1) => void | Promise<void>;
    /**
     * Test-only hook after a target has been stably observed by final validation. Validation
     * observes every target once, then observes the whole set again before returning success.
     */
    onFinalValidationTarget?: (entry: PublicationRecoveryEntry$1, validated: ReadonlyArray<PublicationRecoveryEntry$1>) => void | Promise<void>;
}
/** A write error with the exact recovery inventory. It is never a successful write receipt. */
declare class PublicationInterruptedError$2 extends Error {
    readonly recovery: PublicationRecovery$1;
    constructor(message: string, recovery: PublicationRecovery$1, options?: {
        cause?: unknown;
    });
}
interface AuthoringOutputFile {
    path: string;
    content?: unknown;
    operation?: AuthoringFileOperation;
}
interface AuthoringOutputPlan {
    files: ReadonlyArray<AuthoringOutputFile>;
}
/**
 * Snapshot a destination without making it exist. Apart from a small fixed set of OS-owned root
 * aliases, every lexical component from the filesystem root to the requested path is lstat'ed,
 * so no user-controlled link is ever resolved before it can be rejected.
 */
declare function inspectAuthoringDestination$1(outputDirectory: string, output: AuthoringOutputPlan): Promise<DestinationInspection>;
/**
 * Produce the value accepted by `author write --confirm`. It binds the canonical plan to the
 * compiler contract, exact lexical destination, and filesystem snapshot shown by `author preview`.
 */
declare function hashAuthoringConfirmation$1(plan: AuthoringPlan$1, destination: AuthoringDestinationApproval): string;
/**
 * Publish immutable, generated source through an exclusive hard-link. Replacements require the
 * separate, hash-bound operation carried by the sealed output package.
 */
declare function writeAuthoringOutput$1(outputDirectory: string, output: AuthoringOutputPlan, approval?: AuthoringDestinationApproval, options?: AuthoringPublicationOptions): Promise<{
    directory: string;
    fingerprint: string;
    written: string[];
}>;
/** Verify generated bytes against their manifest before publishing the package. */
declare function writeGeneratedRegisteredBlock$1(outputDirectory: string, generated: GeneratedRegisteredBlock, approval?: AuthoringDestinationApproval, options?: AuthoringPublicationOptions): Promise<{
    directory: string;
    fingerprint: string;
    written: string[];
}>;
/**
 * Continue an interrupted authoring publication. The pending target is published only if it is
 * still missing (for creates) or still has the reviewed pre-replacement hash (for replacements).
 * A target changed by another process is refused, and unrelated paths are never touched.
 */
declare function retryAuthoringPublication$1(recovery: PublicationRecovery$1, options?: AuthoringPublicationOptions): Promise<{
    directory: string;
    fingerprint: string;
    written: string[];
}>;
/** Alias for callers that present retry as an explicit recovery action. */
declare function recoverAuthoringPublication$1(recovery: PublicationRecovery$1, options?: AuthoringPublicationOptions): Promise<{
    directory: string;
    fingerprint: string;
    written: string[];
}>;

/** The impact of replacing a compiler-owned package; never a claim to migrate a site. */
type RegenerationImpactKind = 'new-package' | 'unchanged' | 'style-only' | 'content-defaults' | 'saved-markup-or-structure';
interface RegenerationImpact {
    kind: RegenerationImpactKind;
    changedFiles: readonly string[];
    existingInstanceEffect: string;
    nextStep: string;
    writeAllowed: boolean;
}
/** Compare a reviewed destination snapshot with exact generated bytes. */
declare function classifyRegisteredBlockRegeneration$1(inspection: DestinationInspection, generated: GeneratedRegisteredBlock): Promise<RegenerationImpact>;

/**
 * Extra facts collected by the caller for a particular destination.  They deliberately live
 * outside the plan: a plan can be inspected without granting it authority to write anywhere.
 */
interface AuthoringPreviewContext {
    /** SHA-256 of the canonical plan, normally including the generator version. */
    hash?: string;
    /** SHA-256 confirmation that additionally binds this preview's destination snapshot. */
    confirmationHash?: string;
    /** Absolute or display-safe destination selected for this invocation. */
    destination?: string;
    /** Opaque fingerprint of the destination observed while previewing. */
    destinationFingerprint?: string;
    /** Exact destination paths inspected for this preview. */
    touchedFiles?: ReadonlyArray<AuthoringPreviewTouchedFile>;
    /** Reviewed source-regeneration effect for this destination snapshot. */
    regeneration?: RegenerationImpact;
}
/** A destination-bound output change shown before the confirmation hash. */
interface AuthoringPreviewTouchedFile {
    /** Absolute path inspected by the preview. */
    path: string;
    /** The hash-bound operation selected for this compiler-owned output. */
    operation: 'create' | 'replace';
    /** Whether this exact path existed as a regular file during inspection. */
    exists?: boolean;
}
interface AuthoringPreviewOptions extends AuthoringPreviewContext {
    /** Terminal column count. Defaults to the current stdout width, or 80 when unavailable. */
    width?: number;
    /**
     * Kept for callers which share output options with other commands. Preview intentionally emits
     * no escape sequences, so `NO_COLOR` is always honoured and this option has no visual effect.
     */
    color?: boolean;
}
/**
 * Render an inspectable, non-interactive preview of an authoring plan.
 *
 * The renderer has no I/O and never emits terminal escapes. The CLI may use the same renderer for
 * a TTY and redirected output without risking ANSI in a machine-readable channel. Its only source
 * of nondeterminism would be a terminal width, which is an explicit option and defaults to 80 in
 * non-terminal environments.
 */
declare function renderAuthoringPreview$1(plan: AuthoringPlan$1, options?: AuthoringPreviewOptions): string;

declare class AuthoringStyleError$1 extends Error {
    readonly reason: string;
    readonly source: {
        path: string;
    };
    constructor(reason: string, source: {
        path: string;
    });
}
/** Carry a scanned residual graph into a plan without flattening conditions or double-scoping. */
declare function authoringRulesFromStylesheet$1(rules: readonly CssRule[]): AuthoringCssRule[];
/** The same checked rendering is used before preview, before asset reads, and during compilation. */
declare function renderConfirmedStyleRules$1(rules: readonly AuthoringCssRule[], root: string, assets: readonly AuthoringAsset[], location?: string, foundation?: 'component'): {
    css: string;
    assetIds: Set<string>;
};

/**
 * The single host profile this preview recognises.  Deliberately accepting only a small,
 * explainable shape is safer than putting a source directory into an arbitrary webpack build.
 */
declare const WP_SCRIPTS_PROFILE$1: "wordpress-scripts-block-metadata-v1";
type PluginRegistrationStrategy = 'direct' | 'metadata-collection';
type PluginPlanMode = 'existing' | 'standalone';
type PluginFileOperation = 'create' | 'modify';
type PluginFileContent = string | Buffer;
interface GeneratedBlockPackage {
    /** The block name stored in block.json, such as `acme/feature-grid`. */
    name: string;
    /** Files below the generated block directory. The keys must be safe POSIX relative paths. */
    files: Readonly<Record<string, PluginFileContent>>;
}
interface WpScriptsPluginProfile {
    kind: 'recognized';
    profile: typeof WP_SCRIPTS_PROFILE$1;
    root: string;
    wpScriptsVersion: string;
    packageFile: string;
    buildScript: string;
    sourceRoot: string;
    buildRoot: string;
    entryDiscovery: string;
    registration: PluginRegistrationStrategy;
    registrationFile: string;
    /** The source-relative directory in which a new block belongs. */
    blockDirectory: string;
    /** The build-relative directory produced for a new block. */
    buildDirectory: string;
    metadataCollection?: {
        directory: string;
        manifest: string;
        /** The leaf block directory used by wp-scripts as the metadata collection key. */
        key: string;
    };
}
interface UnsupportedPluginProfile {
    kind: 'absent' | 'unsupported' | 'ambiguous';
    root: string;
    reason: string;
    /** A caller can show this exact option without guessing whether fallback is safe. */
    standaloneAvailable: true;
}
type PluginProfile = WpScriptsPluginProfile | UnsupportedPluginProfile;
interface PluginTouchedFile {
    /** Absolute file path. This is intentionally suitable for an approval UI. */
    path: string;
    relativePath: string;
    operation: PluginFileOperation;
    /** Raw bytes are retained so generated runtime assets are never text-decoded. */
    content: Buffer;
    /** Existing file content from the read-only inspection, never a hash-only blind write. */
    previousContent?: Buffer;
    requiresSeparateAuthorization: boolean;
}
interface PluginOutputPlan {
    /** Compatibility of the generated block source, distinct from file replacement approval. */
    regeneration?: RegenerationImpact;
    mode: PluginPlanMode;
    targetDirectory: string;
    block: {
        name: string;
        directory: string;
        buildDirectory: string;
    };
    profile?: WpScriptsPluginProfile;
    touchedFiles: PluginTouchedFile[];
    notes: string[];
    /** Stable identity for a preview/confirmation layer. */
    fingerprint: string;
}
interface WritePluginOutputOptions {
    /**
     * Exact absolute paths from `touchedFiles` that a user separately approved for replacement.
     * New files do not need this authority. Package and PHP bootstrap edits always do.
     */
    authorizedReplacements?: readonly string[];
    /**
     * Test-only failure injection. A value of 1 throws immediately after the first destination
     * file is published, before the next file can be touched.
     */
    failAfterPublishStep?: number;
    /**
     * Called immediately after each individual destination file is published. Throwing from this
     * hook simulates an interrupted multi-file publication and returns a recovery inventory.
     */
    onPublished?: (entry: PublicationRecoveryEntry, recovery: PublicationRecovery) => void | Promise<void>;
    /**
     * Test-only hook after a target has been stably observed by final validation. The complete set
     * is observed again before success so a later read cannot hide a changed earlier target.
     */
    onFinalValidationTarget?: (entry: PublicationRecoveryEntry, validated: ReadonlyArray<PublicationRecoveryEntry>) => void | Promise<void>;
}
interface WritePluginOutputResult {
    directory: string;
    written: string[];
    fingerprint: string;
}
/** A single destination file in a partial-publication inventory. */
interface PublicationRecoveryEntry {
    path: string;
    /** SHA-256 hashes are prefixed so callers never mistake them for arbitrary identifiers. */
    beforeHash?: string;
    afterHash: string;
    /** The prior bytes are present only for an approved replacement, never for a new file. */
    beforeContent?: Buffer;
}
/**
 * A bounded report for a publication that did not complete. The private staging directory named
 * by recordPath contains its JSON inventory and staged bytes, but no additional published
 * destination files; it can be supplied to retryPluginPublication later.
 */
interface PublicationRecovery {
    directory: string;
    completed: PublicationRecoveryEntry[];
    pending: PublicationRecoveryEntry[];
    /** The subset of completed files whose prior bytes were replaced. */
    replacements: PublicationRecoveryEntry[];
    recordPath?: string;
}
/** A write failed after at least one destination file may have been published. */
declare class PublicationInterruptedError$1 extends Error {
    readonly recovery: PublicationRecovery;
    constructor(message: string, recovery: PublicationRecovery, options?: ErrorOptions);
}
declare class UnsupportedPluginLayoutError$1 extends Error {
    readonly profile: UnsupportedPluginProfile;
    constructor(profile: UnsupportedPluginProfile);
}
/**
 * Detect the one supported existing-plugin profile, without changing the filesystem.  The
 * report includes the script version, source/build roots, discovery method, and registration
 * strategy so an approval screen has facts rather than inferred destination paths.
 */
declare function detectWpScriptsPlugin$1(rootDirectory: string): Promise<PluginProfile>;
/**
 * Plan an existing integration. Unknown and ambiguous layouts intentionally throw before a
 * target is created; the attached profile explicitly offers standalone output.
 */
declare function planExistingPluginOutput$1(hostDirectory: string, generated: GeneratedBlockPackage): Promise<PluginOutputPlan>;
/** Build a complete standalone wp-scripts plugin plan. No files are created until writePluginOutput. */
declare function planStandalonePluginOutput$1(outputDirectory: string, generated: GeneratedBlockPackage): Promise<PluginOutputPlan>;
/**
 * Materialize a previously previewed plan. Existing files are never replaced unless their exact
 * preview paths appear in authorizedReplacements. The complete output is first built in a
 * private sibling staging directory. File renames are individually atomic only when the staging
 * and destination reside on the same filesystem; this function intentionally makes no stronger
 * cross-file atomicity claim.
 */
declare function writePluginOutput$1(plan: PluginOutputPlan, options?: WritePluginOutputOptions): Promise<WritePluginOutputResult>;
/**
 * Finish an interrupted publication from its retained inventory. Files already published must
 * still have their recorded after-hash; pending files must still be absent (creates) or retain
 * their recorded before-hash (replacements). No changed or unrelated file is overwritten.
 */
declare function retryPluginPublication$1(recovery: PublicationRecovery | string, options?: Omit<WritePluginOutputOptions, 'authorizedReplacements'>): Promise<WritePluginOutputResult>;
/** A narrow archive policy check for the standalone release lane. */
declare function assertStandaloneZipEntries$1(entries: readonly string[], blockDirectory: string, runtimeFiles?: readonly string[]): void;

declare function supportedPatternOverrideAttributes$1(block: string, attributes?: Readonly<Record<string, unknown>>): string[];
/**
 * Produce the stable key consumed by a synced pattern's
 * `core/block.content[metadata.name]` object.  It derives only from a
 * producer-owned plan path, never client IDs, random values, or source order.
 */
declare function patternOverrideName$1(path: string): string;
/**
 * Enable the native block-level pattern override contract. The name is
 * block-level because that is WordPress's canonical storage shape: one
 * metadata.name identifies a map of overridden attributes on that block.
 */
declare function applyPatternOverrides$1(node: AuthoringNode, block: string, attributes: Record<string, unknown>, names: Set<string>, diagnostics: AuthoringDiagnostic[]): void;

interface PatternOverrideBinding {
    name: string;
    block: string;
    attribute: string;
    path: readonly number[];
}
interface PatternOverrideContract {
    ok: boolean;
    bindings: PatternOverrideBinding[];
    errors: string[];
}
/**
 * Inspect the compiler's template before it is written into a synced pattern.
 * This is deliberately structural validation, not an invented render layer:
 * WordPress still owns binding resolution and core/block persistence.
 */
declare function validatePatternOverrideContract$1(template: AuthoringTemplate, fields: readonly AuthoringEditableField[]): PatternOverrideContract;
/**
 * Canonical shape WordPress stores in core/block.content for one synced-pattern
 * instance. Callers supply values by metadata.name; no cloned InnerBlocks tree
 * is ever synthesized.
 */
declare function patternOverrideContent$1(values: Readonly<Record<string, Readonly<Record<string, unknown>>>>): Record<string, Record<string, unknown>>;
declare function templateOverrideName$1(attributes: Readonly<Record<string, unknown>>, attribute: string): string | undefined;

/**
 * The upstream exceptions currently approved for the 0.9 testing release.
 *
 * These are deliberately node-level exceptions. They must not turn an entire
 * Axe result, or an arbitrary accessibility failure, into a pass. Each match
 * also requires the exact native control markup and a separately retained
 * WordPress 7.1 control run.
 */
declare const APPROVED_UPSTREAM_EXCEPTION_ID$1: "wordpress-7.1-native-heading-editor-a11y";
declare const APPROVED_UPSTREAM_PARAGRAPH_EXCEPTION_ID$1: "wordpress-7.1-native-paragraph-editor-a11y";
type ApprovedUpstreamExceptionId = typeof APPROVED_UPSTREAM_EXCEPTION_ID$1 | typeof APPROVED_UPSTREAM_PARAGRAPH_EXCEPTION_ID$1;
type ReleaseAcceptanceStatus = 'passed' | 'failed' | 'blocked' | 'engine_error';
interface ReleaseAcceptanceBlocker {
    gate: ProofGateId | 'receipt';
    status: string;
    reason: string;
}
interface AcceptedUpstreamFinding {
    exceptionId: ApprovedUpstreamExceptionId;
    gate: 'accessibility_editor';
    violationId: string;
    target: string;
    basis: string;
}
/**
 * An immutable reference to a separately run native WordPress control. The
 * caller must retain the referenced bytes and verify the hash before passing
 * this descriptor to the acceptance function; a path or a version string alone
 * is never enough to activate the exception.
 */
interface NativeBlockControlEvidence {
    wordpressVersion: string;
    evidence: {
        path: string;
        sha256: `sha256:${string}`;
    };
    /** Parsed standalone-control result; omitted only before loading the file. */
    controlReceipt?: unknown;
}
/** Evidence for the standalone native WordPress Heading editor control. */
type NativeHeadingControlEvidence = NativeBlockControlEvidence;
/** Evidence for the standalone native WordPress Paragraph editor control. */
type NativeParagraphControlEvidence = NativeBlockControlEvidence;
interface ReleaseAcceptanceOptions {
    nativeHeadingControlEvidence?: NativeHeadingControlEvidence;
    nativeParagraphControlEvidence?: NativeParagraphControlEvidence;
}
/**
 * Load and validate the separately retained native control before using it as
 * an exception basis. The returned descriptor carries the parsed control only
 * in memory; summaries contain the immutable reference, not the full payload.
 */
declare function loadNativeHeadingControlEvidence$1(evidence: NativeHeadingControlEvidence): NativeHeadingControlEvidence;
/** Load and validate the retained standalone native Paragraph control. */
declare function loadNativeParagraphControlEvidence$1(evidence: NativeParagraphControlEvidence): NativeParagraphControlEvidence;
interface ReleaseAcceptanceReport {
    /** The unmodified profile evaluation. Raw failures are never rewritten. */
    rawProfile: ProofProfileReport;
    /** Browser/build/fidelity checks, excluding only human manual review. */
    automated: {
        ok: boolean;
        blockers: readonly ReleaseAcceptanceBlocker[];
    };
    /** The publishable 0.9 claim, including the separately supplied manual review. */
    release: {
        ok: boolean;
        status: ReleaseAcceptanceStatus;
        blockers: readonly ReleaseAcceptanceBlocker[];
    };
    /** Exact raw Axe nodes covered by the approved exception, if any. */
    acceptedUpstreamFindings: readonly AcceptedUpstreamFinding[];
    /** The control descriptor supplied for the exception decision, if any. */
    nativeHeadingControlEvidence?: NativeHeadingControlEvidence;
    /** The retained native Paragraph control descriptor, if supplied. */
    nativeParagraphControlEvidence?: NativeParagraphControlEvidence;
}
/**
 * Assess the full WordPress proof without mutating its receipt.
 *
 * `automated.ok` is intended for CI and mutation baselines: it requires every
 * automated full-profile gate, but leaves the human manual-review gate for the
 * release assessment. `release.ok` is the actual 0.9 release decision and
 * therefore also requires a validated manual-review pass. Neither assessment
 * converts raw gate statuses in the supplied receipt.
 */
declare function evaluateReleaseAcceptance$1(receipt: ProofReceiptDocument, options?: ReleaseAcceptanceOptions): ReleaseAcceptanceReport;
/**
 * Short, receipt-safe JSON for release-check output. The full raw Axe payload
 * remains in the WordPress receipt; this summary keeps the release receipt
 * readable while retaining every decision that affected acceptance.
 */
declare function summarizeReleaseAcceptance$1(report: ReleaseAcceptanceReport): {
    rawProfileOk: boolean;
    automatedOk: boolean;
    releaseOk: boolean;
    releaseStatus: ReleaseAcceptanceStatus;
    rawFailures: readonly string[];
    automatedBlockers: readonly ReleaseAcceptanceBlocker[];
    releaseBlockers: readonly ReleaseAcceptanceBlocker[];
    acceptedUpstreamFindings: readonly AcceptedUpstreamFinding[];
    nativeHeadingControlEvidence?: NativeHeadingControlEvidence;
    nativeParagraphControlEvidence?: NativeParagraphControlEvidence;
};

declare const APPROVED_UPSTREAM_EXCEPTION_ID: "wordpress-7.1-native-heading-editor-a11y";
declare const APPROVED_UPSTREAM_PARAGRAPH_EXCEPTION_ID: "wordpress-7.1-native-paragraph-editor-a11y";
declare const AUTHORING_PLAN_VERSION: 1;
declare const GENERATED_REGISTERED_BLOCK_PATHS: readonly ["block.json", "index.js", "edit.js", "save.js", "style.scss", "editor.scss", "block.php"];
declare const PATTERN_OVERRIDE_SOURCE: string;
declare const PROOF_CLAIM_NAMES: readonly ["generated", "built", "editor-verified", "fidelity-checked", "pattern-verified"];
declare const PROOF_GATE_IDS: readonly ["headless_validation", "zip_installation", "plugin_activation", "php_registry", "rest_block_type", "client_registry", "environment_observation", "editor_inserter", "editor_field_editing", "editor_save", "editor_reopen", "frontend_status", "frontend_semantics", "frontend_links", "frontend_media", "frontend_assets", "frontend_runtime_errors", "php_logs", "static_deactivation_html", "static_deactivation_registration", "static_deactivation_assets", "static_deactivation_editor_controls", "pattern_overrides", "visual_regression", "accessibility_editor", "accessibility_frontend", "accessibility_manual_review"];
declare const PROOF_GATE_STATUSES: readonly ["pass", "fail", "skip", "blocked", "not_applicable"];
declare const PROOF_PROFILES: Readonly<Record<"generated" | "built" | "editor-verified" | "fidelity-checked" | "pattern-verified" | "headless" | "runtime" | "editor" | "full", ProofProfile>>;
declare const PROOF_PROFILE_NAMES: readonly ["headless", "runtime", "editor", "full", "generated", "built", "editor-verified", "fidelity-checked", "pattern-verified"];
declare const REGISTERED_BLOCK_TEMPLATE_VERSION: "0.9-static-v11";
declare const STANDALONE_LOCK_TEMPLATE_PACKAGE_COUNT: 1549;
declare const STANDALONE_LOCK_TEMPLATE_VERSION: "wordpress-scripts-34.2.0-lock-v2";
declare const STANDALONE_WP_SCRIPTS_VERSION: "34.2.0";
declare const WORDPRESS_BLOCK_SCHEMA_URL: string;
declare const WORDPRESS_BLOCK_SCHEMA_VERSION: "7.1";
declare const WP_SCRIPTS_PROFILE: "wordpress-scripts-block-metadata-v1";
declare const applyPatternOverrides: typeof applyPatternOverrides$1;
declare const assemble: typeof assemble$1;
declare const assertStandaloneZipEntries: typeof assertStandaloneZipEntries$1;
declare const author: typeof author$1;
declare const authoringRulesFromStylesheet: typeof authoringRulesFromStylesheet$1;
declare const canBeNotApplicable: typeof canBeNotApplicable$1;
declare const canonicalAuthoringPlanHash: typeof hashAuthoringPlan$1;
declare const canonicalAuthoringPlanJson: typeof serializeAuthoringPlan$1;
declare const canonicalJson: typeof canonicalJson$1;
declare const canonicalJsonStringify: typeof canonicalJson$1;
declare const canonicalize: typeof canonicalize$1;
declare const canonicalizeAuthoringPlan: typeof canonicalizeAuthoringPlan$1;
declare const classifyCssUrlReference: typeof classifyCssUrlReference$1;
declare const classifyRegisteredBlockRegeneration: typeof classifyRegisteredBlockRegeneration$1;
declare const collectSiteContext: typeof collectSiteContext$1;
declare const collectSourceEvidence: typeof collectSourceEvidence$1;
declare const compileAuthoringBlock: typeof compileAuthoringPlan$1;
declare const compileAuthoringPlan: typeof compileAuthoringPlan$1;
declare const compileRegisteredBlock: typeof compileRegisteredBlock$1;
declare const compileTailwindBuildGraph: typeof compileTailwindBuildGraph$1;
declare const convert: typeof convert$1;
declare const createDefaultGateRecords: typeof createDefaultProofGateRecords$1;
declare const createDefaultProofGateRecords: typeof createDefaultProofGateRecords$1;
declare const detectWpScriptsPlugin: typeof detectWpScriptsPlugin$1;
declare const emitBlockJson: typeof emitBlockJson$1;
declare const emitEditJs: typeof emitEditJs$1;
declare const emitIndexJs: typeof emitIndexJs$1;
declare const emitPhp: typeof emitPhp$1;
declare const emitSaveJs: typeof emitSaveJs$1;
declare const emitScss: typeof emitScss$1;
declare const evaluateProfile: typeof evaluateProofProfile$1;
declare const evaluateProofProfile: typeof evaluateProofProfile$1;
declare const evaluateProofProfiles: typeof evaluateProofProfiles$1;
declare const evaluateReleaseAcceptance: typeof evaluateReleaseAcceptance$1;
declare const extractIntent: typeof extractIntent$1;
declare const generateRegisteredBlock: typeof compileRegisteredBlock$1;
declare const getProofProfile: typeof getProofProfile$1;
declare const hasTailwindSignal: typeof hasTailwindSignal$1;
declare const hashAuthoringConfirmation: typeof hashAuthoringConfirmation$1;
declare const hashAuthoringPlan: typeof hashAuthoringPlan$1;
declare const hashCanonicalJson: typeof hashCanonicalJson$1;
declare const inspectAuthoringDestination: typeof inspectAuthoringDestination$1;
declare const isProofGateStatus: typeof isProofGateStatus$1;
declare const isProofProfileName: typeof isProofProfileName$1;
declare const isSafeAuthoringRelativePath: typeof isSafeAuthoringRelativePath$1;
declare const loadNativeHeadingControlEvidence: typeof loadNativeHeadingControlEvidence$1;
declare const loadNativeParagraphControlEvidence: typeof loadNativeParagraphControlEvidence$1;
declare const materializeAuthoringPlan: typeof compileRegisteredBlock$1;
declare const normalizeProofGateId: typeof normalizeProofGateId$1;
declare const patternOverrideContent: typeof patternOverrideContent$1;
declare const patternOverrideName: typeof patternOverrideName$1;
declare const planExistingPluginOutput: typeof planExistingPluginOutput$1;
declare const planRegisteredBlockOutput: typeof planRegisteredBlockOutput$1;
declare const planStandalonePluginOutput: typeof planStandalonePluginOutput$1;
declare const previewAuthoringPlan: typeof renderAuthoringPreview$1;
declare const processCssAssets: typeof rewriteCssAssets$1;
declare const prove: typeof runProof$1;
declare const proofClaimGates: typeof proofClaimGates$1;
declare const reportProofRequirements: typeof reportProofRequirements$1;
declare const realize: typeof realize$1;
declare const recoverAuthoringPublication: typeof recoverAuthoringPublication$1;
declare const retryAuthoringPublication: typeof retryAuthoringPublication$1;
declare const recoverPluginPublication: typeof retryPluginPublication$1;
declare const retryPluginPublication: typeof retryPluginPublication$1;
declare const renderAuthoringPreview: typeof renderAuthoringPreview$1;
declare const renderConfirmedStyleRules: typeof renderConfirmedStyleRules$1;
declare const renderResidualCss: typeof renderResidualCss$1;
declare const reportProofProfile: typeof evaluateProofProfile$1;
declare const rewriteCssAssets: typeof rewriteCssAssets$1;
declare const runProof: typeof runProof$1;
declare const scanCssUrlReferences: typeof scanCssUrlReferences$1;
declare const scanStylesheet: typeof scanStylesheet$1;
declare const scopeLocalSelectorList: typeof scopeLocalSelectorList$1;
declare const scopeStylesheet: typeof scopeStylesheet$1;
declare const serializeAuthoringPlan: typeof serializeAuthoringPlan$1;
declare const sha256: typeof sha256$1;
declare const summarizeReleaseAcceptance: typeof summarizeReleaseAcceptance$1;
declare const supportedPatternOverrideAttributes: typeof supportedPatternOverrideAttributes$1;
declare const templateOverrideName: typeof templateOverrideName$1;
declare const validate: typeof validate$1;
declare const validateAuthoringPlan: typeof validateAuthoringPlan$1;
declare const validateBlockMetadata: typeof validateBlockMetadata$1;
declare const validateCssBuildGraph: typeof validateCssBuildGraph$1;
declare const validateGeneratedSources: typeof validateGeneratedSources$1;
declare const validatePatternOverrideContract: typeof validatePatternOverrideContract$1;
declare const writeAuthoringOutput: typeof writeAuthoringOutput$1;
declare const writeGeneratedRegisteredBlock: typeof writeGeneratedRegisteredBlock$1;
declare const writePluginOutput: typeof writePluginOutput$1;

declare const AuthoringGenerationError: typeof AuthoringGenerationError$1;
type AuthoringGenerationError = AuthoringGenerationError$1;
declare const AuthoringPlanValidationError: typeof AuthoringPlanValidationError$1;
type AuthoringPlanValidationError = AuthoringPlanValidationError$1;
declare const AuthoringStyleError: typeof AuthoringStyleError$1;
type AuthoringStyleError = AuthoringStyleError$1;
declare const EvidenceStore: typeof EvidenceStore$1;
type EvidenceStore = EvidenceStore$1;
declare const ImmutableContentError: typeof ImmutableContentError$1;
type ImmutableContentError = ImmutableContentError$1;
declare const ReceiptWriter: typeof ReceiptWriter$1;
type ReceiptWriter = ReceiptWriter$1;
declare const UnsupportedPluginLayoutError: typeof UnsupportedPluginLayoutError$1;
type UnsupportedPluginLayoutError = UnsupportedPluginLayoutError$1;
declare const PublicationInterruptedError: typeof PublicationInterruptedError$2;
type PublicationInterruptedError = PublicationInterruptedError$2;
declare const PluginPublicationInterruptedError: typeof PublicationInterruptedError$1;
type PluginPublicationInterruptedError = PublicationInterruptedError$1;

export { APPROVED_UPSTREAM_EXCEPTION_ID, APPROVED_UPSTREAM_PARAGRAPH_EXCEPTION_ID, AUTHORING_PLAN_VERSION, type AcceptedUpstreamFinding, type AssembleOptions, type AssetLedgerEntry, type AssetOutcome, type AuthorConfig, type AuthorOptions, type AuthorSourceElement, type AuthorSourceEvidence, type AuthorStyleConfig, type AuthoredStyleLedgerEntry, type AuthoredStyleOutcome, type AuthoringAsset, type AuthoringAssetStatus, type AuthoringCoverage, type AuthoringCoverageAsset, type AuthoringCoverageAssetOutcome, type AuthoringCoverageLocation, type AuthoringCoverageStyle, type AuthoringCoverageStyleOutcome, type AuthoringCssDeclaration, type AuthoringCssRule, type AuthoringDestinationApproval, type AuthoringDiagnostic, type AuthoringEditableField, type AuthoringField, type AuthoringFieldMode, type AuthoringFile, type AuthoringFileOperation, AuthoringGenerationError, type AuthoringLockMode, type AuthoringLocking, type AuthoringNode, type AuthoringNodeLock, type AuthoringOutputFile, type AuthoringOutputPlan, type AuthoringPattern, type AuthoringPatternOverride, type AuthoringPlan, AuthoringPlanValidationError, type AuthoringPreviewContext, type AuthoringPreviewOptions, type AuthoringProposal, type AuthoringProposalDecision, type AuthoringProposalNode, type AuthoringPublicationOptions, type AuthoringRole, type AuthoringSource, type AuthoringSourceDecision, type AuthoringSourceFormat, type AuthoringStructureNode, AuthoringStyleError, type AuthoringStyleOutcome, type AuthoringStyleOutcomeKind, type AuthoringStyleStrategy, type AuthoringStyles, type AuthoringTarget, type AuthoringTemplate, type BlockRunnerConfig, type BlockRunnerReport, type CanonicalJsonValue, type CanonicalizeOptions, type CommandName, type CommonOptions, type CompiledAuthoringBlock, type ContentAddressedReference, type ConvertOptions, type CssBuildGraph, type DestinationEntry, type DestinationInspection, type EvidencePutOptions, type EvidenceReference, EvidenceStore, GENERATED_REGISTERED_BLOCK_PATHS, type GateId, type GateRecord, type GateStatus, type AuthoringPlan$1 as GeneratedAuthoringPlan, type GeneratedBlockPackage$1 as GeneratedBlockPackage, type GeneratedRegisteredBlock, type GeneratedSourceFile, type GeneratedSourceKind, type GeneratedSourceManifest, type GeneratedSourceManifestEntry, type GeneratedSourcePath, type HashInput, ImmutableContentError, type InnerBlocksLock, type IntentNode, type IntentTree, type JsonPrimitive, type JsonValue, type MediaConfig, type MediaMapEntry, type MediaResolver, type MediaResult, type NativeBlockControlEvidence, type NativeHeadingControlEvidence, type NativeParagraphControlEvidence, PATTERN_OVERRIDE_SOURCE, PROOF_CLAIM_NAMES, PROOF_GATE_IDS, PROOF_GATE_STATUSES, PROOF_PROFILES, PROOF_PROFILE_NAMES, type PatternOverrideBinding, type PatternOverrideContent, type PatternOverrideContract, type PluginFileContent, type PluginFileOperation, type GeneratedBlockPackage as PluginGeneratedBlockPackage, type PluginOutputPlan, type PluginPlanMode, type PluginProfile, PluginPublicationInterruptedError, type PublicationRecovery as PluginPublicationRecovery, type PublicationRecoveryEntry as PluginPublicationRecoveryEntry, type PluginRegistrationStrategy, type PluginTouchedFile, type ProfileName, type ProofArtifactContract, type ProofArtifactRequirement, type ProofBrowserMatrix, type ProofClaimName, type ProofCommandOptions, type ProofCommandResult, type ProofCommandRunner, type ProofEditableField, type ProofEditableSurface, type ProofEnvironment, type ProofFilePin, type ProofFixture, type ProofGateContext, type ProofGateId, type ProofGateOutcome, type ProofGateRecord, type ProofGateRecords, type ProofGateResult, type ProofGateRunner, type ProofGateStatus, type ProofPatternInstance, type ProofPatternNegativeBinding, type ProofPatternRequiredBinding, type ProofProfile, type ProofProfileEvaluation, type ProofProfileName, type ProofProfileReport, type ProofReceipt, type ProofReceiptDocument, type ProofRequirementClaim, type ProofRequirementReport, type ProofRunOptions, type ProofRunResult, PublicationInterruptedError, type PublicationRecovery$1 as PublicationRecovery, type PublicationRecoveryEntry$1 as PublicationRecoveryEntry, REGISTERED_BLOCK_TEMPLATE_VERSION, type ReceiptReference, type ReceiptWriteResult, ReceiptWriter, type RegisteredBlockOutputPlan, type ReleaseAcceptanceBlocker, type ReleaseAcceptanceOptions, type ReleaseAcceptanceReport, type ReleaseAcceptanceStatus, type ReportItem, type ReportStatus, type ReportSummary, type ResolvedTokens, type ResolverKind, type Rule, type RuleContext, STANDALONE_LOCK_TEMPLATE_PACKAGE_COUNT, STANDALONE_LOCK_TEMPLATE_VERSION, STANDALONE_WP_SCRIPTS_VERSION, type AuthoringPlan as SemanticAuthoringPlan, type Sha256, type SiteContextOptions, type SourceLocation, type StylingRung, type TailwindBuildGraph, type TailwindCompilation, type TailwindCompilationOptions, type TailwindCompiler, type TailwindCompilerInput, type TemplateLock, type TokenConfig, type TokenMatchMode, type TokenResolver, type TokenResolverKind, UnsupportedPluginLayoutError, type UnsupportedPluginProfile, type ValidateOptions, WORDPRESS_BLOCK_SCHEMA_URL, WORDPRESS_BLOCK_SCHEMA_VERSION, WP_SCRIPTS_PROFILE, type WordPressPackagePin, type WpBlock, type WpScriptsPluginProfile, type WritePluginOutputOptions, type WritePluginOutputResult, applyPatternOverrides, assemble, assertStandaloneZipEntries, author, authoringRulesFromStylesheet, canBeNotApplicable, canonicalAuthoringPlanHash, canonicalAuthoringPlanJson, canonicalJson, canonicalJsonStringify, canonicalize, canonicalizeAuthoringPlan, classifyCssUrlReference, classifyRegisteredBlockRegeneration, collectSiteContext, collectSourceEvidence, compileAuthoringBlock, compileAuthoringPlan, compileRegisteredBlock, compileTailwindBuildGraph, convert, createDefaultGateRecords, createDefaultProofGateRecords, detectWpScriptsPlugin, emitBlockJson, emitEditJs, emitIndexJs, emitPhp, emitSaveJs, emitScss, evaluateProfile, evaluateProofProfile, evaluateProofProfiles, evaluateReleaseAcceptance, extractIntent, generateRegisteredBlock, getProofProfile, hasTailwindSignal, hashAuthoringConfirmation, hashAuthoringPlan, hashCanonicalJson, inspectAuthoringDestination, isProofGateStatus, isProofProfileName, isSafeAuthoringRelativePath, loadNativeHeadingControlEvidence, loadNativeParagraphControlEvidence, materializeAuthoringPlan, normalizeProofGateId, patternOverrideContent, patternOverrideName, planExistingPluginOutput, planRegisteredBlockOutput, planStandalonePluginOutput, previewAuthoringPlan, processCssAssets, proofClaimGates, prove, realize, recoverAuthoringPublication, recoverPluginPublication, renderAuthoringPreview, renderConfirmedStyleRules, renderResidualCss, reportProofProfile, reportProofRequirements, retryAuthoringPublication, retryPluginPublication, rewriteCssAssets, runProof, scanCssUrlReferences, scanStylesheet, scopeLocalSelectorList, scopeStylesheet, serializeAuthoringPlan, sha256, summarizeReleaseAcceptance, supportedPatternOverrideAttributes, templateOverrideName, validate, validateAuthoringPlan, validateBlockMetadata, validateCssBuildGraph, validateGeneratedSources, validatePatternOverrideContract, writeAuthoringOutput, writeGeneratedRegisteredBlock, writePluginOutput };