@contentful/experience-design-system-cli 2.37.1-dev-build-ef8b693f.0 → 2.37.1-dev-build-7314a760.0

package/legacy/dist/src/analytics/exit.d.ts

@@ -1,4 +0,0 @@
-import { type CommandFailure } from '@contentful/experience-design-system-backend-pipeline';
-import type { ApiError } from '../apply/api-client.js';
-export declare function exitWithAnalytics(code: number, fields?: CommandFailure): Promise<never>;
-export declare function failureFromApiError(error: ApiError): CommandFailure;

package/legacy/dist/src/analytics/index.d.ts

@@ -1,3 +0,0 @@
-export { bindAnalyticsSessionId, completeActiveCommand, emitSessionStarted, enrichCommandResult, failActiveCommand, flushAnalytics, isPipelineAnalyticsChild, noteCommandStart, recordApplyOutcome, recordContentfulContext, setCliVersion, setPersistedAnalyticsDisabled, } from '@contentful/experience-design-system-backend-pipeline';
-export type { CommandFailure } from '@contentful/experience-design-system-backend-pipeline';
-export { exitWithAnalytics, failureFromApiError } from './exit.js';

package/legacy/dist/src/analyze/composite-closure.d.ts

@@ -1,26 +0,0 @@
-export interface ComponentGraphNode {
-    name: string;
-    slots: Array<{
-        name: string;
-        allowedComponents?: string[];
-    }>;
-}
-interface ClosureNode {
-    name: string;
-    depth: number;
-    path: string[];
-    parents: string[];
-}
-export interface Closure {
-    root: string;
-    nodes: ClosureNode[];
-    containsCycle: boolean;
-    cyclePath?: string[];
-}
-export type NodeStatus = 'ok' | 'warning' | 'error';
-export declare function findRoots(components: ComponentGraphNode[], selected?: Set<string>): string[];
-export declare function computeClosure(root: string, components: ComponentGraphNode[]): Closure;
-export declare function computeAllClosures(components: ComponentGraphNode[], selected?: Set<string>): Map<string, Closure>;
-export declare function aggregateStatus(closure: Closure, perNodeStatus: Map<string, NodeStatus>): NodeStatus;
-export declare function findSharedDeps(closures: Map<string, Closure>): Map<string, string[]>;
-export {};

package/legacy/dist/src/analyze/composition/apply-mapping.d.ts

@@ -1,22 +0,0 @@
-import type { RawComponentDefinition } from '../../types.js';
-import type { CompositionEdge } from './interchange-schema.js';
-export type ApplyMappingResult = {
-    components: RawComponentDefinition[];
-    warnings: string[];
-};
-/**
- * Enrichment pass (spec T7): merge a resolved composition edge list into the
- * extracted components' `allowedComponents`. Runs AFTER extraction; it is the
- * mapping resolver's entire job — populating the one field every downstream
- * graph consumer reads.
- *
- * Slot targeting:
- *  - edge.slot present + slot exists → write there.
- *  - edge.slot present + slot missing → synthesize for high-trust
- *    (typed-slot / adapter) edges; drop-and-warn for `agent` edges.
- *  - edge.slot absent → default slot (isDefault), synthesized if none exists.
- *
- * Edges naming unknown parents/children are dropped-and-warned (§1.3). Inputs
- * are not mutated; a deep-enough clone of touched slots is returned.
- */
-export declare function applyMapping(components: RawComponentDefinition[], edges: CompositionEdge[]): ApplyMappingResult;

package/legacy/dist/src/analyze/composition/candidate-files.d.ts

@@ -1,34 +0,0 @@
-export declare const CANDIDATE_NAME_PATTERNS: RegExp[];
-export declare const CANDIDATE_CONTENT_MARKERS: string[];
-export declare const CANDIDATE_TOKEN_BUDGET = 6000;
-/**
- * Token ceiling for the candidate set INLINED into a single agent prompt.
- * Sized to stay under a 200k-context model once the agent's own system prompt
- * + tool definitions (~105k observed) are added, so a large design system
- * (hundreds of components → many matched files) can't overflow the request and
- * fail resolution. Files beyond the budget are dropped (with a warning), not
- * silently truncated. Distinct from `CANDIDATE_TOKEN_BUDGET`, which sizes the
- * unused per-batch chunking.
- */
-export declare const PROMPT_CANDIDATE_TOKEN_BUDGET = 80000;
-export type CandidateFile = {
-    path: string;
-    content: string;
-};
-export type SelectedCandidate = CandidateFile & {
-    reason: string;
-};
-export declare function selectCandidateFiles(files: CandidateFile[]): SelectedCandidate[];
-/**
- * Cap a candidate set to what fits in a single agent prompt (see
- * `PROMPT_CANDIDATE_TOKEN_BUDGET`). Files are kept smallest-first so the budget
- * admits the most declarations; deterministic tie-break by path. Returns the
- * kept files plus the paths dropped so the caller can warn (silent truncation
- * would read as "resolved everything" when it didn't).
- */
-export declare function capCandidatesToPromptBudget<T extends CandidateFile>(files: T[], budget?: number): {
-    kept: T[];
-    dropped: T[];
-};
-export declare function sliceDeclarationRegions(content: string, markers?: string[], window?: number): string[];
-export declare function batchCandidates(files: CandidateFile[], budget?: number): CandidateFile[][];

package/legacy/dist/src/analyze/composition/composition-cache-key.d.ts

@@ -1,18 +0,0 @@
-/**
- * Derive the `input_hash` for a composition-cache entry (stored in the pipeline
- * DB's `composition_cache` table). Content-addresses the candidate file set
- * (order-independent) plus the producing agent, so a re-run over unchanged
- * files reuses the (token-costly) agent output.
- *
- * Content-hashing — not mtime — means a no-op `git checkout` that only bumps
- * mtime is still a hit. Prompt/skill changes are handled by the `cli_version`
- * column on the row (see `getCliCacheVersion`), so no separate resolver-version
- * constant is needed here.
- */
-export declare function buildCompositionInputHash(input: {
-    files: Array<{
-        path: string;
-        content: string;
-    }>;
-    agent: string;
-}): string;

package/legacy/dist/src/analyze/composition/interchange-schema.d.ts

@@ -1,17 +0,0 @@
-/**
- * The CLI-owned composition interchange format (spec T1).
- *
- * `CompositionEdge[]` is the flat internal runtime view, one edge per
- * parent→child relationship, carrying optional `slot` (T7), `confidence`,
- * and `provenance`. It is easier to merge and dedupe across sources (T2).
- */
-export type EdgeProvenance = 'typed-slot' | 'structural' | 'manifest' | 'doc' | `adapter:${string}` | 'agent';
-export type CompositionEdge = {
-    parent: string;
-    child: string;
-    /** Optional named slot (T7). Default slot when omitted. */
-    slot?: string;
-    /** 1–5 scale, same as select/reject agent tools. */
-    confidence?: number;
-    provenance: EdgeProvenance;
-};

package/legacy/dist/src/analyze/composition/manifest-doc-evidence.d.ts

@@ -1,49 +0,0 @@
-import type { CompositionEdge } from './interchange-schema.js';
-type CandidateFile = {
-    path: string;
-    content: string;
-};
-type ComponentRef = {
-    name: string;
-    sourcePath?: string;
-};
-/**
- * Prompt-injection safeguard for this signal: both parsers below are plain
- * deterministic code, never an LLM prompt. `manifest.json`/`AGENTS.md`
- * content is attacker-adjacent (Figma-authored / free-form prose respectively)
- * but it only ever flows through JSON field access and a fixed regex, then is
- * validated against the real `componentNames` allowlist before an edge is
- * emitted — there is no path from this file's content to model instructions.
- */
-/** Figma/manifest names are kebab-case (`blue-accordion-item`); React exports are PascalCase. */
-export declare function kebabToPascal(name: string): string;
-/**
- * Deterministic parse of a Figma-exported `manifest.json` — no LLM involved.
- * Schema (confirmed against a real design-system manifest):
- *   { component: { name: "blue-accordion" },
- *     variantsMeta: { componentPropertyDefinitions: {
- *       "Slot#1533:33": { type: "SLOT", preferredValues: [{ name: "blue-accordion-item" }] }
- *     } } }
- * The manifest's own `component.name` identifies its owning/parent component
- * (more robust than inferring from directory proximity, since manifest.json
- * typically lives one level below the component's source file, e.g. in a
- * sibling `design/` directory).
- */
-export declare function collectManifestEdges(files: CandidateFile[], componentNames: ReadonlySet<string>): CompositionEdge[];
-/**
- * Deterministic parse of a component-level `AGENTS.md` — no LLM involved.
- * Only a bold-backtick component mention (`` **`ComponentName`** ``) on a
- * line that ALSO carries a composition keyword is accepted, e.g. "Direct
- * **`AccordionItem`** children only." A bare cross-reference mention (no
- * composition keyword on the same line, e.g. "see `other-component`") is
- * rejected — it isn't asserting a parent-child relationship.
- *
- * The doc's owning component is resolved by directory colocation: the
- * component whose `sourcePath` sits in the same directory as the doc file
- * (the real-world convention — `<component>/AGENTS.md` next to
- * `<component>/Component.tsx`).
- */
-export declare function collectAgentsDocEdges(files: CandidateFile[], components: ComponentRef[], componentNames: ReadonlySet<string>): CompositionEdge[];
-/** Both deterministic sources, combined for the `extraEdges` wiring in command.ts. */
-export declare function collectManifestDocEdges(files: CandidateFile[], components: ComponentRef[], componentNames: ReadonlySet<string>): CompositionEdge[];
-export {};

package/legacy/dist/src/analyze/composition/merge-edges.d.ts

@@ -1,19 +0,0 @@
-import type { CompositionEdge, EdgeProvenance } from './interchange-schema.js';
-export type EdgeConflict = {
-    parent: string;
-    child: string;
-    winner: EdgeProvenance;
-    loser: EdgeProvenance;
-};
-export type MergeResult = {
-    edges: CompositionEdge[];
-    conflicts: EdgeConflict[];
-};
-/**
- * Union all edges, resolving conflicts by provenance rank. A conflict is two
- * edges that share `parent::child` but disagree on existence-detail (here:
- * slot placement). The higher-ranked edge wins; the loser is recorded (never
- * silently dropped) so the review UI can surface it. Identical edges (same
- * parent/child/slot) collapse to the highest-ranked copy with no conflict.
- */
-export declare function mergeEdges(all: CompositionEdge[]): MergeResult;

package/legacy/dist/src/analyze/composition/parse-map-edges.d.ts

@@ -1,16 +0,0 @@
-import type { CompositionEdge } from './interchange-schema.js';
-/**
- * Lenient JSONL parser for the composition-mapping agent's tool-call output
- * (spec T4). Mirrors `parseSelectToolCallLines` / `parseToolCallLines` in
- * `@contentful/experience-design-system-generation`'s `agent-runner.ts`: one JSON object per line, each with a `tool`
- * field from a fixed allowlist. A line that fails JSON.parse or validation is
- * DROPPED into `warnings[]` (with a reason) and parsing CONTINUES — no retry,
- * no throw. Non-`{` prose and blank lines are skipped silently.
- */
-export type ParseMapEdgesResult = {
-    edges: CompositionEdge[];
-    warnings: string[];
-};
-export declare function parseMapEdges(raw: string, opts: {
-    componentNames: Set<string>;
-}): ParseMapEdgesResult;

package/legacy/dist/src/analyze/composition/prompt-loader.d.ts

@@ -1,3 +0,0 @@
-/** Resolve a bundled composition prompt from the package-root prompts directory. */
-export declare function resolvePromptPath(fileName: string): string;
-export declare function loadPrompt(fileName: string): string;

package/legacy/dist/src/analyze/composition/resolve-mapping-cli.d.ts

@@ -1,10 +0,0 @@
-export type CompositionCliOptions = {
-    /** `--composition-refresh` — force edge emission to run even over resolved residue. */
-    compositionRefresh?: boolean;
-    /** `--no-cache` — force the composition agent to rerun with the rest of the pipeline. */
-    noCache?: boolean;
-};
-export type ResolvedCompositionSources = {
-    forceAgent: boolean;
-};
-export declare function resolveCompositionSources(opts: CompositionCliOptions): ResolvedCompositionSources;

package/legacy/dist/src/analyze/composition/resolve-mapping.d.ts

@@ -1,59 +0,0 @@
-import type { RawComponentDefinition } from '../../types.js';
-import type { CompositionEdge } from './interchange-schema.js';
-import { type EdgeConflict } from './merge-edges.js';
-export type ResolveMappingResult = {
-    components: RawComponentDefinition[];
-    edges: CompositionEdge[];
-    conflicts: EdgeConflict[];
-    warnings: string[];
-};
-/**
- * Orchestrate composition-edge acquisition and enrichment.
- *
- * Sources by rank: typed-slot / "code slots" (2) > structural usage evidence
- * (3) > manifest (4) > doc (5) > adapter-resolved / extraEdges (6) >
- * edge-emitting agent (7). Manifest/doc edges are computed deterministically outside
- * this function (see manifest-doc-evidence.ts) and joined via `extraEdges`.
- * ALL sources — including the code slots already on the incoming components —
- * are fed into one ranked merge and unioned; non-conflicting edges from every
- * source survive, and on a conflict (same parent+child, different slot) the
- * higher-rank source wins and the loser is recorded. The edge-emitting agent runs only when
- * `forceAgent` is set OR there is residue a higher-rank source
- * didn't cover (routing/cost optimization) — `forceAgent` bypasses that
- * suppression but never changes rank.
- *
- * `runAgentFn` is injected (returns the agent's raw stdout) so this is
- * testable without spawning a subprocess.
- */
-export declare function resolveMapping(input: {
-    components: RawComponentDefinition[];
-    forceAgent?: boolean;
-    files: Array<{
-        path: string;
-        content: string;
-    }>;
-    runAgentFn: (opts: {
-        prompt: string;
-        files: Array<{
-            path: string;
-            content: string;
-        }>;
-    }) => Promise<string>;
-    buildPrompt?: (files: Array<{
-        path: string;
-        content: string;
-    }>, componentNames: string[]) => string;
-    /**
-     * Custom instruction preamble (from `--prompt composition=...`). Replaces the
-     * default guidance line ONLY; the machine-readable output contract + the
-     * component-name allowlist + candidate files are always appended so the
-     * JSONL parser keeps working regardless of the override.
-     */
-    promptOverride?: string;
-    /**
-     * Pre-resolved edges from an external source (e.g. manifest or documentation)
-     * path). They join the ranked merge at their own provenance rank alongside
-     * code slots and other automatic mapping sources.
-     */
-    extraEdges?: CompositionEdge[];
-}): Promise<ResolveMappingResult>;

package/legacy/dist/src/analyze/cycle-detection.d.ts

@@ -1,27 +0,0 @@
-/** A directed edge in the slot-dependency graph. */
-export interface SlotEdge {
-    fromComponent: string;
-    slotName: string;
-    toComponent: string;
-}
-/** A single elementary cycle, with `path[0] === path[path.length - 1]`. */
-export interface SlotCycle {
-    path: string[];
-    edges: SlotEdge[];
-}
-/** Input shape mirroring the slot definition on CDFComponentEntry. */
-export interface ComponentSlotInfo {
-    name: string;
-    slots: Array<{
-        name: string;
-        allowedComponents?: string[];
-    }>;
-}
-export declare function findSlotCycles(components: ComponentSlotInfo[]): SlotCycle[];
-export declare function suggestCycleBreakEdge(cycle: SlotCycle, allCycles: SlotCycle[]): SlotEdge;
-export declare function formatCyclePath(cycle: SlotCycle, maxHops?: number): string;
-export interface CyclePathSegment {
-    kind: 'component' | 'slot' | 'arrow';
-    text: string;
-}
-export declare function formatCyclePathSegments(cycle: SlotCycle, maxHops?: number): CyclePathSegment[];

package/legacy/dist/src/analyze/extract-command.d.ts

@@ -1,7 +0,0 @@
-import type { Command } from 'commander';
-export declare function resolveExtractNoCache(opts: {
-    cache?: boolean;
-    noCache?: boolean;
-}): boolean;
-export declare function collectSourceFiles(directory: string, onProgress?: (scannedCount: number) => void): Promise<string[]>;
-export declare function registerInternalExtractCommand(program: Command): void;

package/legacy/dist/src/analyze/fuzzy-search.d.ts

@@ -1,3 +0,0 @@
-export declare function fuzzyMatches(query: string, text: string): boolean;
-export declare function fuzzyScore(query: string, text: string): number | null;
-export declare function fuzzyFilter(query: string, candidates: string[]): string[];

package/legacy/dist/src/analyze/issue-inheritance.d.ts

@@ -1,8 +0,0 @@
-import type { Closure, NodeStatus } from './composite-closure.js';
-export interface RenderStatus {
-    status: NodeStatus;
-    isOwn: boolean;
-    sourceComponents: string[];
-}
-export declare function computeRenderStatuses(closure: Closure, directIssues: Map<string, NodeStatus>): Map<string, RenderStatus>;
-export declare function pickDrillTarget(ancestor: string, closure: Closure, directIssues: Map<string, NodeStatus>): string | null;

package/legacy/dist/src/analyze/lineage.d.ts

@@ -1,29 +0,0 @@
-import type { ComponentGraphNode } from './composite-closure.js';
-export interface LineageParentEdge {
-    parent: string;
-    slotName: string;
-}
-export interface LineageEdge {
-    from: string;
-    slotName: string;
-    to: string;
-}
-export type LineageChain = LineageEdge[];
-export declare function findDirectParents(target: string, components: ComponentGraphNode[]): LineageParentEdge[];
-export declare function findAllAncestors(target: string, components: ComponentGraphNode[]): Set<string>;
-export declare function findAllAncestorChains(target: string, components: ComponentGraphNode[]): LineageChain[];
-export interface AncestorTreeNode {
-    name: string;
-    incomingSlotName?: string;
-    depth: number;
-    shared: boolean;
-    cycle: boolean;
-    parents: AncestorTreeNode[];
-}
-export declare function buildAncestorTree(target: string, components: ComponentGraphNode[]): AncestorTreeNode;
-export interface AncestorTreeLine {
-    text: string;
-    jumpTarget?: string;
-    depth: number;
-}
-export declare function renderAncestorTree(node: AncestorTreeNode): AncestorTreeLine[];

package/legacy/dist/src/analyze/search-neighborhood.d.ts

@@ -1,3 +0,0 @@
-import type { ComponentGraphNode } from './composite-closure.js';
-export declare function computeDirectNeighborhood(matches: Iterable<string>, graph: ComponentGraphNode[]): Set<string>;
-export declare function findAllAncestors(target: string, graph: ComponentGraphNode[]): Set<string>;

package/legacy/dist/src/analyze/select/command.d.ts

@@ -1,27 +0,0 @@
-import type { ReviewSessionSnapshot } from './types.js';
-import type { PreviewValidationError } from '../../apply/api-client.js';
-/**
- * Load components from the pipeline DB and re-run extraction validation.
- *
- * `validationIssues` is intentionally not persisted (the validator is pure
- * and cheap to re-run), so any cold-start of the review state needs to
- * recompute it before building the review snapshot.
- */
-export declare function loadAndValidateForReview(sessionId: string, projectRoot: string | undefined): Promise<ReviewSessionSnapshot>;
-/**
- * Synthesize SERVER_VALIDATION_FAILED issues onto the review state file's
- * matching components for the wizard's 422 recovery path.
- */
-export declare function patchReviewStateWithValidationErrors(sessionId: string, errors: PreviewValidationError[], opts?: {
-    artifactsRoot?: string;
-}): Promise<{
-    patchedNames: string[];
-    missingNames: string[];
-}>;
-/**
- * Exclude components whose names appear in `names` from the next preview/push.
- * Used by the wizard's "skip and retry" path after a 422.
- */
-export declare function rejectComponentsByName(sessionId: string, names: string[], opts?: {
-    artifactsRoot?: string;
-}): Promise<void>;

package/legacy/dist/src/analyze/select/parser.d.ts

@@ -1,6 +0,0 @@
-import type { RawComponentDefinition } from '../../types.js';
-import type { ReviewSessionSnapshot } from './types.js';
-export type LoadReviewInputOptions = {
-    reviewRoot?: string;
-};
-export declare function loadReviewInput(components: RawComponentDefinition[], options?: LoadReviewInputOptions): Promise<ReviewSessionSnapshot>;

package/legacy/dist/src/analyze/select/persistence.d.ts

@@ -1,22 +0,0 @@
-import type { DatabaseSync } from 'node:sqlite';
-import type { ReviewSessionPaths, ReviewSessionSnapshot } from './types.js';
-export declare function getRefineArtifactsRoot(): string;
-export declare function getRefineSessionPaths(sessionId: string, artifactsRoot: string): Promise<ReviewSessionPaths>;
-export declare function saveReviewState(statePath: string, session: ReviewSessionSnapshot): Promise<void>;
-export declare function appendReviewEvent(eventsPath: string, event: {
-    type: string;
-    payload: Record<string, unknown>;
-}): Promise<void>;
-export declare function ensureRefineSession(sessionId: string, artifactsRoot: string, initialSnapshot: ReviewSessionSnapshot): Promise<ReviewSessionSnapshot>;
-/**
- * Persist scope-gate decisions to `current-review-state.json` so downstream
- * consumers (notably `loadAcceptedNames` in `generate components`) can filter
- * out rejected components. The wizard's scope-gate doesn't drive the rich
- * `analyze select` TUI, so fields that file consumes (resolvedSourcePath,
- * sourceCode) are populated with safe placeholders. Only `name` and `status`
- * matter for `loadAcceptedNames`.
- */
-export declare function writeScopeDecisionsSnapshot(db: DatabaseSync, sessionId: string, decisions: {
-    accepted: string[];
-    rejected: string[];
-}): Promise<void>;

package/legacy/dist/src/analyze/select/preview-annotations.d.ts

@@ -1,26 +0,0 @@
-import type { ServerPreviewResponse } from '@contentful/experience-design-system-types';
-import type { PreviewAnnotation } from './types.js';
-/**
- * Pure mapper from a `ServerPreviewResponse` to a per-component-name
- * `PreviewAnnotation` map. Consumed by the wizard's final-review sidebar
- * (and any other surface that wants to render diff badges next to a
- * component row).
- *
- * The `new` bucket of `ServerPreviewResponse.components` is `CDFComponentEntry[]`
- * — those entries do NOT carry a `name` field on the wire (the name is the
- * KEY in the parent CDF document). So instead of trying to read names off
- * entries, we derive the "new" set as:
- *
- *   new = localNames \ (unchangedNames ∪ changedNames ∪ removedNames)
- *
- * Callers must pass the local CDF document's component keys as `localNames`
- * so we can perform the set difference. Removed components from the server
- * that aren't in the local document are still annotated as `'removed'` (so
- * the detail panel can list them).
- *
- * Precedence: `breaking` > `changed` > `removed` > `new`.
- *
- * Unchanged entries are omitted from the map — callers should treat
- * `map.get(name) === undefined` as "no annotation".
- */
-export declare function applyPreviewAnnotations(preview: ServerPreviewResponse, localNames: readonly string[]): Map<string, PreviewAnnotation>;

package/legacy/dist/src/analyze/select/tui/LegacySelectApp.d.ts

@@ -1,8 +0,0 @@
-import React from 'react';
-type AppProps = {
-    sessionId: string;
-    artifactsRoot: string;
-    reviewRoot?: string;
-};
-export declare function App({ sessionId, artifactsRoot, reviewRoot }: AppProps): React.ReactElement;
-export {};

package/legacy/dist/src/analyze/select/tui/components/ComponentDetail.d.ts

@@ -1,19 +0,0 @@
-import React from 'react';
-import type { PreviewAnnotation, ReviewComponentDetail } from '../../types.js';
-type ComponentDetailProps = {
-    component: ReviewComponentDetail;
-    sourceCode: string | null;
-    draftValue: string;
-    editMode: boolean;
-    sourceVisible: boolean;
-    jsonScrollOffset: number;
-    sourceScrollX: number;
-    sourceScrollY: number;
-    terminalWidth: number;
-    previewAnnotation?: PreviewAnnotation;
-    onSaveDraft: (value: string) => void;
-    onDiscardDraft: () => void;
-    onScrollChange: (offset: number) => void;
-};
-export declare function ComponentDetail({ component, sourceCode, draftValue, editMode, sourceVisible, jsonScrollOffset, sourceScrollX, sourceScrollY, terminalWidth, previewAnnotation, onSaveDraft, onDiscardDraft, }: ComponentDetailProps): React.ReactElement;
-export {};

package/legacy/dist/src/analyze/select/tui/components/ComponentRationalePanel.d.ts

@@ -1,10 +0,0 @@
-import React from 'react';
-import type { ComponentRationale } from '../../../../session/db.js';
-export type ComponentRationalePanelProps = {
-    data: ComponentRationale;
-    scrollOffset: number;
-    width: number;
-    height: number;
-    active: boolean;
-};
-export declare function ComponentRationalePanel({ data, scrollOffset, width, height, active, }: ComponentRationalePanelProps): React.ReactElement;

package/legacy/dist/src/analyze/select/tui/components/FieldEditor.d.ts

@@ -1,67 +0,0 @@
-import React from 'react';
-import { findSlotCycles, type ComponentSlotInfo } from '../../../cycle-detection.js';
-type PropMetadata = {
-    rationale?: string | null;
-    sourceStartLine?: number | null;
-    sourceEndLine?: number | null;
-};
-export type FieldEditorMetadata = {
-    /** Absolute path to the component's source file. Null/undefined = unknown. */
-    sourcePath?: string | null;
-    /** Full source text of the component (used by the source-view panel). */
-    componentSource?: string | null;
-    /** Per-prop metadata keyed by prop name. */
-    props?: Record<string, PropMetadata>;
-};
-export type FieldEditorProps = {
-    value: string;
-    width: number;
-    height: number;
-    fixedHeight?: boolean;
-    active?: boolean;
-    onChange: (value: string) => void;
-    onSave: () => void;
-    onDiscard: () => void;
-    onExit?: () => void;
-    metadata?: FieldEditorMetadata;
-    onTogglePropRationale?: () => void;
-    propRationaleKey?: string;
-    onToggleComponentRationale?: () => void;
-    componentRationaleKey?: string;
-    onToggleSourceExternal?: () => void;
-    onTextEntryActiveChange?: (active: boolean) => void;
-    projectSlotGraph?: ComponentSlotInfo[];
-    currentComponentName?: string;
-    onDirtyChange?: (isDirty: boolean) => void;
-    discardTrigger?: number;
-    initialFocusTarget?: {
-        kind: 'description';
-    } | {
-        kind: 'prop' | 'slot';
-        name: string;
-    };
-    showHiddenProps?: boolean;
-    showInlineRationales?: boolean;
-    /** Pinned inside the box above the rows, in row and field-edit modes. Counts as `headerHeight` rows. */
-    header?: React.ReactNode;
-    headerHeight?: number;
-};
-export declare function simulateGraphWithCandidate(projectSlotGraph: ComponentSlotInfo[], selfName: string, currentSlots: {
-    name: string;
-    allowedComponents: string[];
-}[], targetSlotName: string, candidate: string): ComponentSlotInfo[];
-export declare function introducesNewCycle(before: ReturnType<typeof findSlotCycles>, next: ReturnType<typeof findSlotCycles>): boolean;
-export declare function computeAllowedComponentCandidates(projectSlotGraph: ComponentSlotInfo[], selfName: string, currentSlots: {
-    name: string;
-    allowedComponents: string[];
-}[], targetSlotName: string): string[];
-export declare function simulateGraphWithReplacement(projectSlotGraph: ComponentSlotInfo[], selfName: string, currentSlots: {
-    name: string;
-    allowedComponents: string[];
-}[], targetSlotName: string, replaceIndex: number, candidate: string): ComponentSlotInfo[];
-export declare function computeAllowedComponentReplacementCandidates(projectSlotGraph: ComponentSlotInfo[], selfName: string, currentSlots: {
-    name: string;
-    allowedComponents: string[];
-}[], targetSlotName: string, replaceIndex: number): string[];
-export declare function FieldEditor({ value, width, height, fixedHeight, active, onChange, onSave, onDiscard, onExit, metadata, onTogglePropRationale, propRationaleKey, onToggleComponentRationale, componentRationaleKey, onToggleSourceExternal, onTextEntryActiveChange, projectSlotGraph, currentComponentName, onDirtyChange, discardTrigger, initialFocusTarget, showHiddenProps, showInlineRationales, header, headerHeight, }: FieldEditorProps): React.ReactElement;
-export {};

package/legacy/dist/src/analyze/select/tui/components/FinalizeDialog.d.ts

@@ -1,22 +0,0 @@
-import React from 'react';
-import type { ComponentTypeSummary } from '@contentful/experience-design-system-types';
-/** Max removed-component lines shown at once; the rest scroll with arrow keys.
- *  Exported so the parent's scroll-offset clamping stays in sync. */
-export declare const FINALIZE_REMOVED_WINDOW = 6;
-type FinalizeDialogProps = {
-    accepted: number;
-    rejected: number;
-    needsReview: number;
-    onConfirm: () => void;
-    onCancel: () => void;
-    /** Components that will be DELETED from the target space on push, from a
-     *  preview scoped to the accepted set. */
-    removed?: ComponentTypeSummary[];
-    /** Status of the accepted-set preview fired when the dialog opened. While
-     *  'running', the deletion section shows a spinner instead of a (stale) list. */
-    previewStatus?: 'idle' | 'running' | 'done' | 'error';
-    /** Scroll offset into the removed list (owned by the parent; arrow keys adjust it). */
-    removedScrollOffset?: number;
-};
-export declare function FinalizeDialog({ accepted, rejected, needsReview, onConfirm, onCancel, removed, previewStatus, removedScrollOffset, }: FinalizeDialogProps): React.ReactElement;
-export {};

package/legacy/dist/src/analyze/select/tui/components/GotoBanner.d.ts

@@ -1,31 +0,0 @@
-import React from 'react';
-export interface GotoRow {
-    label: string;
-    jumpTarget: string;
-    kind?: string;
-}
-export interface GotoBannerProps {
-    title: string;
-    rows: GotoRow[];
-    /** Index used to highlight + window. Indexes `rows` directly by default. */
-    cursor: number;
-    /**
-     * Override the row index the cursor sits on, when `cursor` indexes a subset
-     * (e.g. a jumpable projection) rather than `rows`. Windowing and the default
-     * highlight center on this instead of `cursor` when provided.
-     */
-    cursorRowIndex?: number;
-    /** Max rows rendered at once. Larger lists window around the cursor. */
-    maxRows?: number;
-    /** Constrain the box to a fixed column width (e.g. the sidebar slot). */
-    width?: number;
-    /** Footer keybinding hint. Rendered dim below the list when given. */
-    footerHint?: string;
-    /**
-     * Escape hatch for feature-specific row rendering. Receives the row, its
-     * index into `rows`, and whether the cursor is on it. Falls back to a
-     * generic pointer row.
-     */
-    renderRow?: (row: GotoRow, index: number, isCursor: boolean) => React.ReactElement;
-}
-export declare function GotoBanner({ title, rows, cursor, cursorRowIndex, maxRows, width, footerHint, renderRow, }: GotoBannerProps): React.ReactElement;