import { type NormalizedCatalog, type Tree, type VendoRouteMap } from "../../contract/index.js";
import type { FloorDependencies } from "./deps.js";
import type { Check } from "./types.js";
/** The app's name is its panel display title. Echoing the ask back ("Create a
 *  chat dashboard that displays the user's…") ships a truncated sentence as
 *  the title of every fresh install's first app, so the cap is a validation
 *  gate, not just prompt guidance: an over-long name routes to repair with
 *  the message below. Create-only — stored apps with long names keep editing
 *  fine (the edit path never re-validates the name).
 *
 *  It lives HERE, with the check that enforces it, rather than with the prompt
 *  sections that used to declare it: the floor must not import the generation
 *  pipeline (§7.3). */
export declare const APP_NAME_MAX_CHARS = 40;
/** One fact issue, anchored: `where` is the locus, `message` continues the
 *  sentence from it. Read as one line (`node "n3" prop "rows" binds …`) they
 *  are the validator's issue strings; read as a pair they are a {@link Finding}. */
export interface FactIssue {
    where: string;
    message: string;
}
/** The validator's flat issue-string form of an anchored fact issue. */
export declare const factIssueLine: ({ where, message }: FactIssue) => string;
export declare const isRecord: (value: unknown) => value is Record<string, unknown>;
export declare const isRuntimeBound: (value: unknown) => boolean;
export declare const catalogIssues: (tree: Tree, 
/** Names only — the generated map's KEYS are the vocabulary this check
 *  measures against, so an entry's shape is none of its business. */
components: Record<string, unknown> | undefined, catalog: NormalizedCatalog) => Promise<FactIssue[]>;
/**
 * Where an element may be WRITTEN — the rule the RENDERER cannot state. The tree
 * renderer hands `children` to every node it renders (`packages/ui`
 * renderer.tsx `builtinContent`), and reads an element only at the props a
 * component actually paints, so a chart handed a child, or an element written at
 * a key that is no slot, has always painted as nothing at all: the model wrote
 * content, the person got a blank, and no stage said a word. WHAT goes in a slot
 * is not measured here — any Kit element may sit in any slot, the way it may in
 * normal React, and whether it belongs there is the judge's to grade.
 *
 * One function, both artifacts: a wire tree and the tree a `.tsx` screen paints
 * are the same tree and reach the same renderer, so this is a check in the wire
 * floor (`kit-nesting`) and a stage of the component-screen gauntlet
 * (`nesting`), never two implementations that could disagree.
 *
 * A `host`/`generated` node is somebody else's implementation, which may nest
 * whatever it likes — only a name the renderer resolves to the Kit is measured.
 */
export declare const kitNestingIssues: (tree: Tree) => FactIssue[];
/**
 * A `<Link to>` that will never move anybody.
 *
 * `resolveVendoRoute` answers `undefined` two ways — a name the host never
 * registered, and a registered path whose `:params` the link left unfilled — and
 * the brick renders the SAME dead text for both. That is a silent break of
 * exactly the kind the nesting rule above exists to catch: the model wrote a way
 * out of the screen, the person got dead words, and generation said it passed.
 * So both refusals move to where they can be repaired, and they move together:
 * catching one and not the other would leave a hole precisely where a reader
 * would assume there is none.
 *
 * One function, both artifacts, for the reason `kitNestingIssues` is: a wire tree
 * and the tree a `.tsx` screen paints reach the same renderer.
 *
 * Both messages hand over what the repair needs — the registered names for the
 * first, the unfilled param names for the second — because a link SELECTS from
 * the host's registry and fills its blanks; it never writes a URL.
 */
export declare const routeIssues: (tree: Tree, routes: VendoRouteMap | undefined) => FactIssue[];
/**
 * The checks floor's static half: the screen's own text, type-checked by `tsc`
 * against the declarations the floor already holds (screen-typings.ts). One
 * compiler answers "does this file name a surface it may, with props that exist,
 * types that fit, and data fields the response really carries". It degrades to
 * silence when no compiler is reachable (screen-tsc.ts), so a missing toolchain
 * never blocks a build.
 *
 * The screen text is the STORED `app.tsx`, verbatim — the same `hash`/`bytes`/
 * `text` triple `commitApp` lands — so a finding's line numbers are the author's
 * own. A document with no screen has nothing to type-check.
 */
/**
 * The built-in fact checks. Every finding is `block`: a fact is not a matter of
 * taste.
 */
export declare const factChecks: () => Check[];
/**
 * The compiler static half (§7.1 + Track A): a `tsc` program over the stored
 * screen + generated typings. It spins a compiler, so it runs ONLY where a bad
 * screen is blocked from a user and the cost is affordable — the validate door —
 * never inside the synchronous scripted-create loop the perf gate guards.
 * Degrades to silence when no compiler is available.
 */
export declare const screenTypesCheck: (deps: FloorDependencies) => Check;
//# sourceMappingURL=facts.d.ts.map