@contentful/experience-design-system-cli 2.38.0 → 2.38.1-dev-build-6d903339.0

package/dist/src/tui/import/steps/07-scope-gate/use-scope-gate.d.ts

@@ -0,0 +1,76 @@
+import type { ScopeComponent, ScopeDecisions } from './types.js';
+interface UseScopeGateOptions {
+    components: ScopeComponent[];
+    onConfirm: (decisions: ScopeDecisions) => void;
+    onQuit: () => void;
+}
+type FocusedColumn = 'main' | 'added-components';
+export interface PendingRejectCascade {
+    target: string;
+    ancestors: string[];
+    descendants: string[];
+}
+export declare function useScopeGate({ components, onConfirm, onQuit }: UseScopeGateOptions): {
+    totalWidth: number;
+    columnPlan: {
+        layout: "single" | "two-column";
+        main: number;
+        added: number;
+    };
+    panelLayout: import("./columns.js").ScopeGatePanelLayout;
+    visibleCount: number;
+    panelMaxRows: number;
+    groupedItems: import("./graph/index.js").SidebarItem[];
+    graph: import("./graph/index.js").ScopeGraph;
+    hasGroupRoots: boolean;
+    expandedGroups: Set<string>;
+    toggleExpanded: (rootName: string) => void;
+    visibleRows: import("./sidebar/components/GroupedSidebar.js").VisibleRow[];
+    safeCursor: number;
+    scrollOffset: number;
+    selectionStateByKey: Map<string, "accepted" | "rejected" | "undecided">;
+    aiFlaggedByKey: Map<string, boolean>;
+    dimPredicate: ((componentKey: string) => boolean) | undefined;
+    columnOneView: "flat" | "grouped";
+    focusedColumn: FocusedColumn;
+    showHelp: boolean;
+    closeHelp: () => void;
+    cyclesPanelOpen: boolean;
+    cyclesCursor: number;
+    slotCycles: import("./graph/cycle-detection.js").SlotCycle[];
+    aiRationalePanelOpen: boolean;
+    aiCursor: number;
+    aiRows: {
+        label: string;
+        jumpTarget: string;
+    }[];
+    aiExcludedCount: number;
+    pendingRejectCascade: PendingRejectCascade | null;
+    addedComponents: import("./columns.js").AddedComponentEntry[];
+    safeAddedComponentsCursor: number;
+    counters: {
+        accepted: number;
+        rejected: number;
+        undecided: number;
+        groups: number;
+        total: number;
+    };
+    search: {
+        searchOpen: boolean;
+        setSearchOpen: import("react").Dispatch<import("react").SetStateAction<boolean>>;
+        searchQuery: string;
+        setSearchQuery: import("react").Dispatch<import("react").SetStateAction<string>>;
+        autocompleteCandidates: string[];
+        setAutocompleteCandidates: import("react").Dispatch<import("react").SetStateAction<string[]>>;
+        jumpFilterTarget: string | null;
+        setJumpFilterTarget: import("react").Dispatch<import("react").SetStateAction<string | null>>;
+        columnOneView: "flat" | "grouped";
+        setColumnOneView: import("react").Dispatch<import("react").SetStateAction<"flat" | "grouped">>;
+        activeFilters: Set<import("./sidebar/step-filters.js").FilterCategory>;
+        setActiveFilters: import("react").Dispatch<import("react").SetStateAction<Set<import("./sidebar/step-filters.js").FilterCategory>>>;
+        showHelp: boolean;
+        setShowHelp: import("react").Dispatch<import("react").SetStateAction<boolean>>;
+    };
+    searchMatches: string[];
+};
+export {};

package/dist/src/tui/import/steps/08-generation/logic.d.ts

@@ -0,0 +1,27 @@
+import type { GenerationProgress } from './types.js';
+export declare function initialProgress(): GenerationProgress;
+/** Token mapping runs only when there is something to map and tokens to map it from. */
+export declare function shouldRunMapTokens(counts: {
+    mappablePropCount: number;
+    rawTokenCount: number;
+}): boolean;
+/** "5 components accepted." or, with some left out, "5 components accepted, 2 excluded due to validation errors." */
+export declare function formatAcceptanceSummary(counts: {
+    accepted: number;
+    autoRejected: number;
+}): string;
+/** The screen's description: what was accepted, what is happening to it, and whether the tokens are used. */
+export declare function describeGeneration(input: {
+    acceptedCount: number;
+    agent: string;
+    hasTokens: boolean;
+}): string;
+/** The rows the generating screen shows for this progress. */
+export declare function progressRows(progress: GenerationProgress, agent: string): Array<{
+    text: string;
+    complete: boolean;
+    progress?: {
+        done: number;
+        total: number;
+    };
+}>;

package/dist/src/tui/import/steps/08-generation/map-tokens.d.ts

@@ -0,0 +1,14 @@
+import type { GenerationInput } from './types.js';
+export interface MapTokensPlan {
+    /** False when there is nothing to map, in which case the command is not run. */
+    eligible: boolean;
+    mappablePropCount: number;
+    rawTokenCount: number;
+}
+/**
+ * Prepares the generated session for token mapping and says whether it is worth running. The map tokens command works
+ * on one session, so the token universe is copied into the generated one: from the token session when extraction made
+ * one, or restored from the saved tokens.json when an existing catalog was reused (there is no token session then).
+ * Then it counts the design props that are tokens and the raw tokens. Reads and writes the pipeline database.
+ */
+export declare function prepareMapTokens(input: Pick<GenerationInput, 'tokenSessionId' | 'tokensPath'>, generatedSessionId: string): Promise<MapTokensPlan>;

package/dist/src/tui/import/steps/08-generation/run.d.ts

@@ -0,0 +1,22 @@
+import { checkAgentAuth, runGenerateComponentsSession, runMapTokens } from '@contentful/experience-design-system-backend-pipeline';
+import { prepareMapTokens } from './map-tokens.js';
+import { saveDecisions } from './save-decisions.js';
+import type { GenerationInput, GenerationProgress, GenerationResult } from './types.js';
+export interface GenerationDeps {
+    checkAgentAuth: typeof checkAgentAuth;
+    saveDecisions: typeof saveDecisions;
+    runGenerate: typeof runGenerateComponentsSession;
+    runMapTokens: typeof runMapTokens;
+    prepareMapTokens: typeof prepareMapTokens;
+}
+/**
+ * The whole stage, in the order the wizard ran it:
+ *  1. Wait for the cache check that ran while the scope gate was open, then save the decisions. Both write to the
+ *     pipeline database and the cache has to be restored first. With nothing accepted the stage ends here.
+ *  2. Generate the accepted components in-process. The orchestrator handles per-component cache lookup, so the names
+ *     from the cache check are forwarded as `precomputedCachedNames` to skip a redundant lookup.
+ *  3. Map tokens onto the generated session. Skipped when there is nothing to map.
+ * A failed token mapping after a successful generation is an error to show. It neither retries nor throws away what was
+ * generated.
+ */
+export declare function runGeneration(input: GenerationInput, onProgress: (progress: GenerationProgress) => void, deps?: GenerationDeps): Promise<GenerationResult>;

package/dist/src/tui/import/steps/08-generation/save-decisions.d.ts

@@ -0,0 +1,8 @@
+import type { GenerationInput } from './types.js';
+/**
+ * Applies the scope decisions to the session and writes the review snapshot that `generate components` reads to leave
+ * out rejected components. Without the snapshot the generator would process rejected components anyway.
+ * Uses `applyScopeDecisions` and `writeScopeDecisionsSnapshot` from backend-pipeline, which are identical to legacy's.
+ * Both write to the pipeline database, so this runs only after the cache check has finished restoring into it.
+ */
+export declare function saveDecisions(input: Pick<GenerationInput, 'sessionId' | 'decisions'>): Promise<void>;

package/dist/src/tui/import/steps/08-generation/screen.d.ts

@@ -0,0 +1,12 @@
+import React from 'react';
+import type { GenerationProgress } from './types.js';
+interface GenerationScreenProps {
+    progress: GenerationProgress;
+    agent: string;
+    acceptedCount: number;
+    hasTokens: boolean;
+    stepNumber: number;
+    totalSteps: number;
+}
+export declare function GenerationScreen({ progress, agent, acceptedCount, hasTokens, stepNumber, totalSteps, }: GenerationScreenProps): React.ReactElement;
+export {};

package/dist/src/tui/import/steps/08-generation/types.d.ts

@@ -0,0 +1,47 @@
+import type { GenerationHandoff } from '@contentful/experience-design-system-types/handoff';
+export interface GenerationInput {
+    /** The extraction session the scope was decided on. */
+    sessionId: string;
+    decisions: {
+        accepted: string[];
+        rejected: string[];
+    };
+    /**
+     * The cache check that ran while the scope gate was open, which restores cached definitions into the pipeline
+     * database. The stage waits for it before saving the decisions, since both write to that database.
+     */
+    cachedNames: Promise<string[]>;
+    tokensPath: string;
+    /** The token session extraction recorded, or null when an existing tokens.json was reused. */
+    tokenSessionId: string | null;
+    existingEntitiesPath: string | null;
+    agent: string;
+    agentModel?: string;
+    promptOverrides: string[];
+    /** A custom prompt for `generate components`, saved in the config. Passed to the command as it is. */
+    generatePromptPath?: string;
+    noCache: boolean;
+    /** Whether a token catalog is in use. It changes the wording of the screen, not what runs. */
+    hasTokens: boolean;
+}
+/** One line per thing the screen shows, in the order it shows them. */
+export interface GenerationProgress {
+    /** Components finished, out of the total, and the one being worked on. Null until the first progress line. */
+    components: {
+        done: number;
+        total: number;
+        current: string;
+    } | null;
+    mapTokens: 'idle' | 'running' | 'complete';
+    /** Whether token mapping will run at all; unknown until the generated components have been looked at. */
+    mapTokensEligible: boolean | null;
+}
+export type GenerationStepName = 'save decisions' | 'generate components' | 'map tokens' | `${string} auth check`;
+export type GenerationResult = {
+    ok: true;
+    generation: GenerationHandoff;
+} | {
+    ok: false;
+    step: GenerationStepName;
+    message: string;
+};

package/dist/src/tui/import/steps/08-generation/use-generation.d.ts

@@ -0,0 +1,14 @@
+import type { GenerationInput, GenerationProgress, GenerationResult } from './types.js';
+export type GenerationState = {
+    status: 'running';
+    progress: GenerationProgress;
+} | {
+    status: 'done';
+    result: GenerationResult;
+};
+/**
+ * Runs the generation stage once for the given input and reports its progress. Passing a different input starts a new
+ * run; passing nothing leaves the stage idle. A run that finishes after the input changed or the screen went away is
+ * ignored.
+ */
+export declare function useGeneration(input: GenerationInput | undefined): GenerationState | undefined;

package/dist/src/tui/import/steps/09-review/components/ComponentRationalePanel.d.ts

@@ -0,0 +1,10 @@
+import React from 'react';
+import type { ComponentRationale } from '@contentful/experience-design-system-backend-pipeline';
+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/dist/src/tui/import/steps/09-review/components/FieldEditor.d.ts

@@ -0,0 +1,67 @@
+import React from 'react';
+import { findSlotCycles, type ComponentSlotInfo } from '../../07-scope-gate/graph/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/dist/src/tui/import/steps/09-review/components/FinalizeDialog.d.ts

@@ -0,0 +1,22 @@
+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/dist/src/tui/import/steps/09-review/components/HighlightedLine.d.ts

@@ -0,0 +1,9 @@
+import React from 'react';
+export type HighlightPart = {
+    text: string;
+    color?: string;
+    dim?: boolean;
+};
+export declare function HighlightedLine({ parts }: {
+    parts: readonly HighlightPart[];
+}): React.ReactElement;

package/dist/src/tui/import/steps/09-review/components/JsonPanel.d.ts

@@ -0,0 +1,11 @@
+import React from 'react';
+type JsonPanelProps = {
+    label: string;
+    value: string;
+    scrollOffset: number;
+    width: number;
+    height: number;
+    active: boolean;
+};
+export declare function JsonPanel({ label, value, scrollOffset, width, height, active }: JsonPanelProps): React.ReactElement;
+export {};

package/{legacy/dist/src/import/tui → dist/src/tui/import/steps/09-review}/components/LivePreviewSummary.d.ts

@@ -1,6 +1,6 @@
 import React from 'react';
-import type { PreviewAnnotation } from '../../../analyze/select/types.js';
-import type { UseLivePreviewReturn } from '../useLivePreview.js';
+import type { PreviewAnnotation } from '../types.js';
+import type { UseLivePreviewReturn } from '../use-live-preview.js';
 type LivePreviewSummaryProps = {
     enabled: boolean;
     previewAnnotations: ReadonlyMap<string, PreviewAnnotation>;

package/dist/src/tui/import/steps/09-review/components/QuitDialog.d.ts

@@ -0,0 +1,8 @@
+import React from 'react';
+type QuitDialogProps = {
+    hasUnsavedDrafts: boolean;
+    onConfirm: () => void;
+    onCancel: () => void;
+};
+export declare function QuitDialog({ hasUnsavedDrafts, onConfirm, onCancel }: QuitDialogProps): React.ReactElement;
+export {};

package/dist/src/tui/import/steps/09-review/components/RationaleLine.d.ts

@@ -0,0 +1,21 @@
+import React from 'react';
+export type RationaleLineData = {
+    kind: 'heading';
+    text: string;
+} | {
+    kind: 'text';
+    text: string;
+    dim?: boolean;
+} | {
+    kind: 'label';
+    text: string;
+    prefix?: string;
+    suffix?: string;
+    color?: string;
+} | {
+    kind: 'blank';
+};
+export declare function RationaleLine({ line, active }: {
+    line: RationaleLineData;
+    active: boolean;
+}): React.ReactElement;

package/dist/src/tui/import/steps/09-review/components/RationalePanel.d.ts

@@ -0,0 +1,15 @@
+import React from 'react';
+export type RationaleRow = {
+    name: string;
+    kind: 'prop' | 'slot';
+    rationale: string;
+};
+export type RationalePanelProps = {
+    componentName: string;
+    rows: RationaleRow[];
+    scrollOffset: number;
+    width: number;
+    height: number;
+    active: boolean;
+};
+export declare function RationalePanel({ componentName, rows, scrollOffset, width, height, active, }: RationalePanelProps): React.ReactElement;

package/{legacy/dist/src/import/tui → dist/src/tui/import/steps/09-review}/components/ReviewComponentPanel.d.ts

@@ -1,8 +1,8 @@
 import React from 'react';
 import type { CDFComponentEntry } from '@contentful/experience-design-system-types';
-import type { CdfReviewEntry } from '../hooks/useReviewSession.js';
-import type { UseReviewEditorResult } from '../hooks/useReviewEditor.js';
-import type { UseLivePreviewReturn } from '../useLivePreview.js';
+import type { CdfReviewEntry } from '../types.js';
+import type { UseReviewEditorResult } from '../use-review-editor.js';
+import type { UseLivePreviewReturn } from '../use-live-preview.js';
 import { type ReviewDetailsEditorProps } from './ReviewDetailsEditor.js';
 type ReviewDetailsEditorConfig = Pick<ReviewDetailsEditorProps, 'componentRationale' | 'reviewMetadata' | 'reviewEditor' | 'width' | 'height' | 'sourceBorderColor' | 'jsonValue' | 'sidebarFocused' | 'fieldEditor'>;
 export type ReviewComponentPanelProps = ReviewDetailsEditorConfig & {

package/{legacy/dist/src/import/tui → dist/src/tui/import/steps/09-review}/components/ReviewDetailsEditor.d.ts

@@ -1,7 +1,7 @@
 import React from 'react';
-import { type FieldEditorProps } from '../../../analyze/select/tui/components/FieldEditor.js';
-import { type ReviewDetailsPanelProps } from '../steps/review-details-panel.js';
-import type { UseReviewEditorResult } from '../hooks/useReviewEditor.js';
+import { type FieldEditorProps } from './FieldEditor.js';
+import { type ReviewDetailsPanelProps } from '../review-details-panel.js';
+import type { UseReviewEditorResult } from '../use-review-editor.js';
 type ReviewEditorPanelState = Pick<UseReviewEditorResult, 'panelOpen' | 'panelScrollOffset' | 'tokenReviewRow' | 'tokenReviewEditing' | 'tokenReviewEditCursor' | 'tokenReviewEditSelection' | 'showJson' | 'jsonScrollOffset' | 'currentTokenSuggestions'>;
 export type ReviewDetailsEditorProps = Omit<ReviewDetailsPanelProps, 'editor' | 'panelOpen' | 'panelScrollOffset' | 'tokenSuggestions' | 'tokenReviewRow' | 'tokenReviewEditing' | 'tokenReviewEditCursor' | 'tokenReviewEditSelection' | 'showJson' | 'jsonScrollOffset'> & {
     reviewEditor: ReviewEditorPanelState;

package/{legacy/dist/src/import/tui → dist/src/tui/import/steps/09-review}/components/ReviewDialogs.d.ts

@@ -1,7 +1,7 @@
 import React from 'react';
 import type { ComponentTypeSummary } from '@contentful/experience-design-system-types';
-import type { UseFinalizePreviewReturn } from '../useFinalizePreview.js';
-import type { UseReviewSurfaceStateResult } from '../hooks/useReviewSurfaceState.js';
+import type { UseFinalizePreviewReturn } from '../use-finalize-preview.js';
+import type { UseReviewSurfaceStateResult } from '../use-review-surface-state.js';
 import { type ReviewStatusEntry } from './ReviewStatus.js';
 export type ReviewFinalizeDialogsProps = {
     showFinalize: boolean;

package/{legacy/dist/src/import/tui → dist/src/tui/import/steps/09-review}/components/ReviewStatus.d.ts

@@ -1,5 +1,5 @@
 import React from 'react';
-import type { ReviewComponentStatus } from '../../../analyze/select/types.js';
+import type { ReviewComponentStatus } from '../types.js';
 export type ReviewStatusCounts = {
     accepted: number;
     rejected: number;

package/dist/src/tui/import/steps/09-review/components/ScrollablePanel.d.ts

@@ -0,0 +1,14 @@
+import React from 'react';
+type ScrollablePanelProps = {
+    title: string;
+    width: number;
+    height: number;
+    active: boolean;
+    totalLines: number;
+    visibleStart: number;
+    visibleEnd: number;
+    borderColor?: string;
+    children: React.ReactNode;
+};
+export declare function ScrollablePanel({ title, width, height, active, totalLines, visibleStart, visibleEnd, borderColor, children, }: ScrollablePanelProps): React.ReactElement;
+export {};

package/dist/src/tui/import/steps/09-review/components/TokenReviewPanel.d.ts

@@ -0,0 +1,30 @@
+import React from 'react';
+import type { CDFComponentEntry } from '@contentful/experience-design-system-types';
+export type TokenPropSuggestion = {
+    propName: string;
+    paths: string[];
+    suggested: string[];
+    allowed: string[];
+};
+export type TokenReviewToken = {
+    path: string;
+    kind: string;
+};
+/**
+ * Design-token props on `entry` with a declared token kind. `paths` is the
+ * full compatible token universe when a token catalog is available; `allowed`
+ * remains the current subset.
+ */
+export declare function collectTokenSuggestions(entry: CDFComponentEntry, availableTokens?: TokenReviewToken[]): TokenPropSuggestion[];
+export type TokenReviewPanelProps = {
+    componentName: string;
+    suggestions: TokenPropSuggestion[];
+    selectedRow: number;
+    editing: boolean;
+    editCursor: number;
+    editSelection: Set<string>;
+    width: number;
+    height: number;
+    active: boolean;
+};
+export declare function TokenReviewPanel({ componentName, suggestions, selectedRow, editing, editCursor, editSelection, width, height, active, }: TokenReviewPanelProps): React.ReactElement;

package/dist/src/tui/import/steps/09-review/components/removed-components-text.d.ts

@@ -0,0 +1,7 @@
+import type { ComponentTypeSummary } from '@contentful/experience-design-system-types';
+/** Header line for the removed-components surfaces (deletion panel + finalize
+ *  dialog). Kept in one place so both read identically. `withExpandHint` adds
+ *  the panel's "[d] to expand/collapse" affordance, which the dialog omits. */
+export declare function removedComponentsHeader(count: number, withExpandHint: boolean): string;
+/** One bullet line per removed component, matching the deletion panel. */
+export declare function removedComponentLine(rc: ComponentTypeSummary): string;

package/dist/src/tui/import/steps/09-review/components/wrap-text.d.ts

@@ -0,0 +1 @@
+export declare function wrapText(text: string, innerWidth: number): string[];

package/{legacy/dist/src/import/tui/steps/GenerateReviewStep.d.ts → dist/src/tui/import/steps/09-review/generate-review-step.d.ts}

@@ -17,7 +17,7 @@ export declare function sortComponentsForSidebar<T extends {
     key: string;
     entry: CDFComponentEntry;
 }>(components: T[], cycleParticipants?: Set<string>): T[];
-export { computeCycleAutoRejectTargets } from '../../cycle-auto-reject.js';
+export { computeCycleAutoRejectTargets } from './graph/cycle-auto-reject.js';
 export interface BreakingComponent {
     componentName: string;
     changes: BreakingChange[];

package/{legacy/dist/src/import → dist/src/tui/import/steps/09-review/graph}/cycle-auto-reject.d.ts

@@ -1,4 +1,4 @@
-import type { ComponentGraphNode } from '../analyze/composite-closure.js';
+import type { ComponentGraphNode } from '../../07-scope-gate/graph/composite-closure.js';
 export declare function computeCycleAutoRejectTargets(slotCycles: Array<{
     path: string[];
 }>, graph: ComponentGraphNode[]): Set<string>;

package/{legacy/dist/src/analyze → dist/src/tui/import/steps/09-review/graph}/cycle-view.d.ts

@@ -1,5 +1,5 @@
-import type { SlotCycle } from './cycle-detection.js';
-import { type SlotGraphInput } from './slot-graph.js';
+import type { SlotCycle } from '../../07-scope-gate/graph/cycle-detection.js';
+import { type SlotGraphInput } from '../../07-scope-gate/graph/slot-graph.js';
 export interface CycleView {
     pushBlocking: SlotCycle[];
     structural: Set<string>;

package/dist/src/tui/import/steps/09-review/graph/issue-inheritance.d.ts

@@ -0,0 +1,8 @@
+import type { Closure, NodeStatus } from '../../07-scope-gate/graph/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/dist/src/tui/import/steps/09-review/graph/selection-cascade.d.ts

@@ -0,0 +1,3 @@
+import type { ComponentGraphNode } from '../../07-scope-gate/graph/composite-closure.js';
+export declare function computeRejectCascade(target: string, components: ComponentGraphNode[]): Set<string>;
+export declare function computeAcceptCascade(target: string, components: ComponentGraphNode[]): Set<string>;

package/{legacy/dist/src/import/tui/steps → dist/src/tui/import/steps/09-review/helpers}/enumerate-cycle-breaks.d.ts

@@ -1,5 +1,5 @@
 import type { CDFComponentEntry } from '@contentful/experience-design-system-types';
-import type { SlotCycle, SlotEdge } from '../../../analyze/cycle-detection.js';
+import type { SlotCycle, SlotEdge } from '../../07-scope-gate/graph/cycle-detection.js';
 export type BreakEdge = SlotEdge;
 /** Row shape accepted by {@link enumerateCycleBreaks}. */
 export interface BreakEnumComponent {

package/{legacy/dist/src/import/tui → dist/src/tui/import/steps/09-review}/history.d.ts

@@ -1,5 +1,5 @@
 import type { CDFComponentEntry } from '@contentful/experience-design-system-types';
-import type { ReviewComponentStatus } from '../../analyze/select/types.js';
+import type { ReviewComponentStatus } from './types.js';
 export interface HistorySnapshot {
     components: CdfReviewEntrySnapshot[];
     autoRejected: string[];

package/dist/src/tui/import/steps/09-review/preview-annotations.d.ts

@@ -0,0 +1,26 @@
+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/import/tui/steps → dist/src/tui/import/steps/09-review}/review-details-panel.d.ts

@@ -1,6 +1,6 @@
 import React from 'react';
-import { type TokenPropSuggestion } from '../../../analyze/select/tui/components/TokenReviewPanel.js';
-import type { ComponentRationale, ComponentReviewMetadata } from '../../../session/db.js';
+import { type TokenPropSuggestion } from './components/TokenReviewPanel.js';
+import type { ComponentRationale, ComponentReviewMetadata } from '@contentful/experience-design-system-backend-pipeline';
 type ReviewPanel = 'none' | 'prop-rationale' | 'component-rationale' | 'source' | 'token-review';
 export type ReviewDetailsPanelProps = {
     selectedKey: string;

package/{legacy/dist/src/import/tui/hooks → dist/src/tui/import/steps/09-review}/review-input.d.ts

@@ -1,5 +1,5 @@
-import type { ImmediateInputKey } from '../../../analyze/select/tui/hooks/useImmediateInput.js';
-import type { UseReviewEditorResult } from './useReviewEditor.js';
+import type { ImmediateInputKey } from '../07-scope-gate/sidebar/hooks/useImmediateInput.js';
+import type { UseReviewEditorResult } from './use-review-editor.js';
 type ReviewOverlayInputState = {
     loading: boolean;
     loadError: string | null;