@contentful/experience-design-system-cli 2.37.1-dev-build-799db3ac.0 → 2.37.1-dev-build-e5882940.0

package/dist/src/tui/import/steps/07-scope-gate/sidebar/components/GotoBanner.d.ts

@@ -0,0 +1,32 @@
+import React from 'react';
+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;
+export {};

package/dist/src/tui/import/steps/07-scope-gate/sidebar/components/GroupedSidebar.d.ts

@@ -0,0 +1,93 @@
+import React from 'react';
+import type { CDFComponentEntry } from '@contentful/experience-design-system-types';
+import { type ComponentGraphNode, type NodeStatus } from '../../graph/composite-closure.js';
+import type { PreviewAnnotation, RenderStatus } from '../types.js';
+export interface GroupedSidebarItem {
+    key: string;
+    entry: CDFComponentEntry;
+    status: NodeStatus;
+}
+export interface GroupedSidebarProps {
+    items: GroupedSidebarItem[];
+    cycleParticipants?: Set<string>;
+    selectedIdx: number;
+    selectedRowIdx?: number;
+    onSelect: (idx: number) => void;
+    expandedGroups: Set<string>;
+    onToggleExpanded: (rootName: string) => void;
+    width: number;
+    height?: number;
+    title?: string;
+    wrapLabels?: boolean;
+    focused: boolean;
+    renderStatusByKey?: Map<string, RenderStatus>;
+    previewAnnotationByKey?: Map<string, PreviewAnnotation>;
+    scrollOffset?: number;
+    visibleCount?: number;
+    alwaysExpanded?: boolean;
+    showFlatTier?: boolean;
+    selectionStateByKey?: Map<string, 'accepted' | 'rejected' | 'undecided'>;
+    aiFlaggedByKey?: Map<string, boolean>;
+    dimPredicate?: (componentKey: string) => boolean;
+    viewMode?: 'grouped' | 'flat';
+    visibleRows?: VisibleRow[];
+    graph: ComponentGraphNode[];
+    filterVisibleKeys?: Set<string>;
+}
+type RowKind = 'cycle' | 'empty' | 'group-root' | 'group-child' | 'standalone' | 'flat' | 'flat-header';
+export interface VisibleRow {
+    kind: RowKind;
+    key: string;
+    label: string;
+    indent: number;
+    aggregateGlyph?: string | null;
+    sharedSuffix?: boolean;
+    cycleChild?: boolean;
+    itemIdx: number;
+    rootName?: string;
+}
+export declare function buildVisibleRows(props: {
+    items: GroupedSidebarItem[];
+    cycleParticipants: Set<string>;
+    expandedGroups: Set<string>;
+    alwaysExpanded?: boolean;
+    showFlatTier?: boolean;
+    viewMode?: 'grouped' | 'flat';
+    graph: ComponentGraphNode[];
+    filterVisibleKeys?: Set<string>;
+}): VisibleRow[];
+export declare function visibleItemOrder(props: {
+    items: GroupedSidebarItem[];
+    cycleParticipants: Set<string>;
+    expandedGroups: Set<string>;
+    alwaysExpanded?: boolean;
+    showFlatTier?: boolean;
+    graph: ComponentGraphNode[];
+}): number[];
+export declare function labelStyleFor(input: {
+    row: VisibleRow;
+    isCursor: boolean;
+    wouldDim: boolean;
+}): {
+    color: string | undefined;
+    bold: boolean;
+    dim: boolean;
+};
+export declare function selectionGlyphStyleFor(selState: 'accepted' | 'rejected' | 'undecided' | undefined, isCycleRow: boolean): {
+    glyph: string | null;
+    color: string | undefined;
+    dim: boolean;
+    bold: boolean;
+};
+export declare function inheritanceGlyphStyleFor(input: {
+    status: RenderStatus['status'] | undefined;
+    isOwn: boolean;
+    isCursor: boolean;
+}): {
+    glyph: string | null;
+    color: string | undefined;
+    dim: boolean;
+    bold: boolean;
+};
+export declare function GroupedSidebar(props: GroupedSidebarProps): React.ReactElement;
+export {};

package/dist/src/tui/import/steps/07-scope-gate/sidebar/components/HelpOverlay.d.ts

@@ -0,0 +1,21 @@
+import React from 'react';
+export type HelpSection = {
+    title: string;
+    entries: {
+        keys: string;
+        label: string;
+    }[];
+};
+type HelpOverlayProps = {
+    mode: 'analyze' | 'validate' | 'review';
+    sections?: undefined;
+    onClose: () => void;
+    handleInput?: boolean;
+} | {
+    mode?: undefined;
+    sections: HelpSection[];
+    onClose: () => void;
+    handleInput?: boolean;
+};
+export declare function HelpOverlay(props: HelpOverlayProps): React.ReactElement;
+export {};

package/dist/src/tui/import/steps/07-scope-gate/sidebar/components/LegendEntry.d.ts

@@ -0,0 +1,2 @@
+import React from 'react';
+export declare function legendEntry(keyBracket: string, label: string, active?: boolean): React.ReactElement;

package/dist/src/tui/import/steps/07-scope-gate/sidebar/components/SearchMatchSummary.d.ts

@@ -0,0 +1,11 @@
+import React from 'react';
+export type SearchMatchSummaryProps = {
+    open: boolean;
+    query: string;
+    matches: number;
+    total: number;
+    autocompleteCandidates: string[];
+    hidden?: boolean;
+    marginTop?: number;
+};
+export declare function SearchMatchSummary({ open, query, matches, total, autocompleteCandidates, hidden, marginTop, }: SearchMatchSummaryProps): React.ReactElement | null;

package/dist/src/tui/import/steps/07-scope-gate/sidebar/components/badge.d.ts

@@ -0,0 +1,13 @@
+import React from 'react';
+import type { PreviewAnnotation } from '../types.js';
+export type PreviewBadgeValue = {
+    char: string;
+    color: string;
+    bold?: boolean;
+    dim?: boolean;
+};
+export declare function previewBadge(annotation: PreviewAnnotation | undefined): PreviewBadgeValue | null;
+export declare function PreviewBadge({ badge, highlighted, }: {
+    badge: PreviewBadgeValue | null;
+    highlighted?: boolean;
+}): React.ReactElement;

package/dist/src/tui/import/steps/07-scope-gate/sidebar/components/windowed-panel.d.ts

@@ -0,0 +1,17 @@
+import type { ReactElement, ReactNode } from 'react';
+export type WindowDirection = 'up' | 'down';
+/** Size a standalone panel to the terminal while reserving a small safety margin. */
+export declare function terminalPanelHeight(rows: number, reservedRows?: number): number;
+export interface WindowedPanelProps {
+    width: number;
+    height?: number;
+    title?: string;
+    focused: boolean;
+    children: ReactNode;
+}
+/** Shared frame for panels whose viewport must not change with their contents. */
+export declare function WindowedPanel({ width, height, title, focused, children }: WindowedPanelProps): ReactElement;
+export declare function WindowIndicator({ direction, count }: {
+    direction: WindowDirection;
+    count: number;
+}): ReactElement;

package/dist/src/tui/import/steps/07-scope-gate/sidebar/group-collapse.d.ts

@@ -0,0 +1,2 @@
+import type { Closure } from '../graph/composite-closure.js';
+export declare function resolveGroupRoot(key: string, closures: Map<string, Closure>, cycleSet: Set<string>): string | undefined;

package/dist/src/tui/import/steps/07-scope-gate/sidebar/hooks/sidebar-search-state.d.ts

@@ -0,0 +1,17 @@
+import type { FilterCategory } from '../step-filters.js';
+export declare function useSidebarSearchState(): {
+    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<FilterCategory>;
+    setActiveFilters: import("react").Dispatch<import("react").SetStateAction<Set<FilterCategory>>>;
+    showHelp: boolean;
+    setShowHelp: import("react").Dispatch<import("react").SetStateAction<boolean>>;
+};

package/dist/src/tui/import/steps/07-scope-gate/sidebar/hooks/use-terminal-size.d.ts

@@ -0,0 +1,6 @@
+export type TerminalSize = {
+    columns: number;
+    rows: number;
+};
+/** Keep layout consumers synchronized with terminal resize events. */
+export declare function useTerminalSize(): TerminalSize;

package/dist/src/tui/import/steps/07-scope-gate/sidebar/hooks/useImmediateInput.d.ts

@@ -0,0 +1,20 @@
+type ImmediateInputKey = {
+    upArrow: boolean;
+    downArrow: boolean;
+    leftArrow: boolean;
+    rightArrow: boolean;
+    pageDown: boolean;
+    pageUp: boolean;
+    return: boolean;
+    escape: boolean;
+    ctrl: boolean;
+    shift: boolean;
+    tab: boolean;
+    shiftTab: boolean;
+    backspace: boolean;
+    delete: boolean;
+    meta: boolean;
+};
+export type ImmediateInputHandler = (input: string, key: ImmediateInputKey) => void;
+export declare function useImmediateInput(handler: ImmediateInputHandler, enabled?: boolean): void;
+export {};

package/dist/src/tui/import/steps/07-scope-gate/sidebar/hooks/useOverlayPanel.d.ts

@@ -0,0 +1,13 @@
+export interface UseOverlayPanelOptions {
+    toggleKey: string;
+    onClose?: () => void;
+}
+export interface UseOverlayPanelResult {
+    isOpen: boolean;
+    open: () => void;
+    close: () => void;
+    handleInput: (input: string, key: {
+        escape?: boolean;
+    }) => boolean;
+}
+export declare function useOverlayPanel(opts: UseOverlayPanelOptions): UseOverlayPanelResult;

package/dist/src/tui/import/steps/07-scope-gate/sidebar/lineage-layout.d.ts

@@ -0,0 +1,68 @@
+/** Maximum layout rows; the active terminal height determines the actual budget. */
+export declare const VISIBLE_COUNT = 200;
+/** Maximum supported panel window; normal terminals remain terminal-sized. */
+export declare const MAX_PANEL_ROWS = 200;
+/** Floors — both surfaces stay usable even on a small terminal. */
+export declare const SIDEBAR_MIN = 4;
+export declare const MIN_PANEL_ROWS = 4;
+/**
+ * Fallback when `stdout.rows` is unavailable (piped output, tests). No TTY
+ * means Ink is not interactively repainting, so there is no flicker risk — we
+ * assume enough height for a terminal-sized sidebar so the non-interactive
+ * render is complete and unclipped.
+ */
+export declare const FALLBACK_ROWS = 40;
+/**
+ * Vertical space consumed by everything ABOVE/BELOW the columns row. The panel
+ * shares the columns row, so the fit constraint while open is simply
+ * `FIXED_OVERHEAD + panelBoxHeight <= rows`.
+ */
+export declare const FIXED_OVERHEAD: number;
+export declare const PANEL_BOX_CHROME = 6;
+/**
+ * L2e — fixed vertical chrome around the sidebar in the BASE (no-panel) case,
+ * counting EVERYTHING that is not a variable sidebar entry row: the wizard
+ * header bar, the counter strip (with its blank separator), the cycle banner,
+ * the nothing-selected /
+ * AI-exclusion hint, the GroupedSidebar box borders + scroll indicator, the
+ * focused-detail block, and the wrapping legend region. The value intentionally
+ * leaves a small safety margin so resize-induced wrapping does not overflow.
+ */
+export declare const BASE_CHROME_OVERHEAD = 18;
+export interface LineageLayoutInput {
+    /** Terminal height in rows (`stdout.rows`, or the fallback). */
+    rows: number;
+    /** Whether the lineage panel is currently open. */
+    panelOpen: boolean;
+    /** Number of lineage entries — caps the panel window so it never over-allocates. */
+    entryCount?: number;
+}
+export interface LineageLayout {
+    /** Rows the sidebar should render (`visibleCount`). Constant across open/closed. */
+    sidebarVisible: number;
+    /** Rows a sidebar replacement panel should window to (`maxRows`). */
+    panelMaxRows: number;
+}
+/**
+ * The sidebar height is constant (the panel replaces it in the same slot, so
+ * there is nothing to shrink). Both values are derived from the terminal so
+ * resizing grows or shrinks the viewport without content-driven layout changes.
+ */
+export declare function computeLineageLayout({ rows, panelOpen, entryCount }: LineageLayoutInput): LineageLayout;
+export interface SidebarBudget {
+    /** Rows the GroupedSidebar should render (`visibleCount`). */
+    sidebarVisibleCount: number;
+    /** Rows a sidebar replacement panel should window to (`maxRows`). */
+    panelMaxRows: number;
+}
+/**
+ * L2e — autoscale the BASE frame to the terminal height. Even with the lineage
+ * panel closed, the visible-row budget follows `stdout.rows` minus
+ * `BASE_CHROME_OVERHEAD` so the whole frame stays within the terminal while
+ * preserving the shared panel-open sizing behavior.
+ *
+ * Floor: `BASE_CHROME_OVERHEAD + SIDEBAR_MIN`. Below it `SIDEBAR_MIN`
+ * (usability) intentionally wins over the fit — a terminal that small can't
+ * host the chrome regardless.
+ */
+export declare function computeSidebarBudget({ rows, panelOpen, entryCount }: LineageLayoutInput): SidebarBudget;

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

@@ -0,0 +1,2 @@
+import type { HelpSection } from './components/HelpOverlay.js';
+export declare function createSidebarViewsHelpSection(includeBreaking: boolean): HelpSection;

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

@@ -0,0 +1,13 @@
+type SearchInputKey = {
+    tab: boolean;
+    backspace: boolean;
+};
+type SearchInputOptions = {
+    query: string;
+    names: string[];
+    setQuery: (value: string | ((current: string) => string)) => void;
+    setCandidates: (value: string[]) => void;
+};
+export declare function handleSidebarSearchInput(input: string, key: SearchInputKey, { query, names, setQuery, setCandidates }: SearchInputOptions): boolean;
+export declare function formatSearchMatchSummary(matches: number, total: number): string;
+export {};

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

@@ -0,0 +1,18 @@
+import type { ComponentGraphNode, Closure } from '../graph/composite-closure.js';
+import { type GroupedSidebarItem } from './components/GroupedSidebar.js';
+export declare function collectExpandedGroupRoots(closures: Map<string, Closure>, cycleParticipants: Iterable<string>): Set<string>;
+export declare function computeSidebarViewToggle({ currentView, currentKey, currentScroll, visibleCount, items, cycleParticipants, expandedGroups, graph, showFlatTier, }: {
+    currentView: 'grouped' | 'flat';
+    currentKey: string | null | undefined;
+    currentScroll: number;
+    visibleCount: number;
+    items: GroupedSidebarItem[];
+    cycleParticipants: Set<string>;
+    expandedGroups: Set<string>;
+    graph: ComponentGraphNode[];
+    showFlatTier?: boolean;
+}): {
+    view: 'grouped' | 'flat';
+    cursor: number;
+    scroll: number;
+};

package/dist/src/tui/import/steps/07-scope-gate/sidebar/step-filters.d.ts

@@ -0,0 +1,19 @@
+export type FilterCategory = 'broken' | 'cycles' | 'deleted';
+export interface FilterDataSources {
+    /** Component keys that participate in a slot cycle. */
+    cycles?: Iterable<string>;
+    /** Component keys the step considers "broken" (issue/warning/AI-flagged). */
+    broken?: Iterable<string>;
+    /** Component keys marked for deletion (GenerateReview only). */
+    deleted?: Iterable<string>;
+}
+export declare function computeFilterKeys(input: {
+    filters: Iterable<FilterCategory>;
+    data: FilterDataSources;
+}): Set<string> | undefined;
+export declare function intersectFilterKeys(a: Set<string> | undefined, b: Set<string> | undefined): Set<string> | undefined;
+export declare function buildFlatDimPredicate(input: {
+    viewMode: 'grouped' | 'flat';
+    searchQuery: string;
+    filterVisibleKeys: Set<string> | undefined;
+}): ((componentKey: string) => boolean) | undefined;

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

@@ -0,0 +1,8 @@
+export declare const PALETTE: {
+    readonly info: "#1773EB";
+    readonly success: "#00C459";
+    readonly error: "#E44F20";
+    readonly warning: "#FFDA00";
+    readonly muted: "#8B8D91";
+    readonly border: "#C4D1DE";
+};

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

@@ -0,0 +1,7 @@
+import type { NodeStatus } from '../graph/composite-closure.js';
+export type PreviewAnnotation = 'new' | 'changed' | 'removed' | 'breaking';
+export interface RenderStatus {
+    status: NodeStatus;
+    isOwn: boolean;
+    sourceComponents: string[];
+}

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

@@ -0,0 +1,19 @@
+import { type ScopeGraph } from './graph/index.js';
+import type { Decision, ScopeComponent, ScopeDecisions } from './types.js';
+export type DecisionState = Map<string, Decision>;
+export type DecisionAction = {
+    type: 'accept';
+    name: string;
+} | {
+    type: 'reject';
+    name: string;
+} | {
+    type: 'toggle-all';
+} | {
+    type: 'accept-unflagged';
+};
+export declare function reduceDecisions(state: DecisionState, action: DecisionAction, components: ScopeComponent[], graph: ScopeGraph): DecisionState;
+/** Whether rejecting `name` touches 2 or more other components, so the screen has to ask first. */
+export declare function rejectNeedsConfirmation(graph: ScopeGraph, name: string, state: DecisionState): boolean;
+/** Everything not accepted counts as rejected, as legacy's `partition` did. */
+export declare function partitionDecisions(components: ScopeComponent[], state: DecisionState): ScopeDecisions;

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

@@ -0,0 +1,24 @@
+import type { ScopeComponentRow } from '@contentful/experience-design-system-backend-pipeline';
+/**
+ * One row of the gate. The loader always fills in the slots, but the screen is handed whatever the caller has, and
+ * legacy's screen accepted rows without them (and without the AI fields), so those stay optional here.
+ */
+export type ScopeComponent = Omit<ScopeComponentRow, 'aiDecision' | 'aiReason' | 'needsReview' | 'slots'> & {
+    aiDecision?: 'accepted' | 'rejected' | 'failed' | null;
+    aiReason?: string | null;
+    needsReview?: boolean;
+    slots?: ScopeComponentRow['slots'];
+};
+export type Decision = 'accepted' | 'rejected' | 'undecided';
+/** What the user confirmed. Becomes `ImportHandoff.scope`; the legacy wizard saves it and starts generation. */
+export interface ScopeDecisions {
+    accepted: string[];
+    rejected: string[];
+}
+export type ScopeGateLoad = {
+    ok: true;
+    components: ScopeComponent[];
+} | {
+    ok: false;
+    message: string;
+};

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

@@ -0,0 +1,31 @@
+import type { ScopeHandoff } from '@contentful/experience-design-system-types/handoff';
+import { type CacheCheckInput } from './cache-check.js';
+import { loadScopeGate } from './load.js';
+import type { ScopeDecisions, ScopeGateLoad } from './types.js';
+export type ScopeGateFlow = {
+    status: 'failed';
+    message: string;
+} | {
+    status: 'deciding';
+    load: Extract<ScopeGateLoad, {
+        ok: true;
+    }>;
+    confirm: (decisions: ScopeDecisions) => void;
+}
+/** Confirmed before the cache check finished. */
+ | {
+    status: 'preparing';
+} | {
+    status: 'confirmed';
+    scope: ScopeHandoff;
+};
+interface Deps {
+    load: typeof loadScopeGate;
+    checkCache: (input: CacheCheckInput) => Promise<string[]>;
+}
+/** `input` is undefined until the extraction stage has produced a session, so the hook can be called unconditionally. */
+export declare function useScopeGateFlow(input: {
+    sessionId: string;
+    cache: CacheCheckInput;
+} | undefined, deps?: Deps): ScopeGateFlow | undefined;
+export {};

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/index.d.ts

@@ -3,3 +3,4 @@ export { TokenInputScreen } from './02-token-input/screen.js';
 export { PathValidationScreen } from './03-path-validation/screen.js';
 export { CredentialsScreen } from './04-credentials/screen.js';
 export { TokenReuseScreen } from './05-token-reuse/screen.js';
+export { ExtractionScreen } from './06-extraction/screen.js';

package/legacy/dist/src/import/tui/WizardApp.d.ts

@@ -14,14 +14,6 @@ export declare function buildGenerateComponentsArgs(opts: {
     restoreCache?: boolean;
     cachedComponents?: string[];
 }): string[];
-export declare function buildGenerateTokensArgs(opts: {
-    rawTokensPath: string;
-    agent: string;
-    model?: string;
-    bedrock?: boolean;
-    noCache?: boolean;
-    promptOverrides?: string[];
-}): string[];
 export declare function buildMapTokensArgs(opts: {
     sessionId: string;
     agent: string;

package/legacy/dist/src/import/tui/handoff.d.ts

@@ -0,0 +1,37 @@
+import { type ImportHandoff } from '@contentful/experience-design-system-types/handoff';
+/** The wizard state the early stages produce. Every field is one the stage used to write. */
+export interface HandoffState {
+    credentialsSkipped: boolean;
+    tokensPath?: string;
+    tokenSessionId?: string | null;
+    tokenCount?: number;
+    tokenGenerationStatus?: 'complete';
+    outDir?: string;
+    extractSessionId?: string;
+    compositionPhase?: 'done' | 'cache-hit';
+    selectionAgentStatus?: 'complete';
+    existingEntitiesStatus?: 'idle' | 'complete' | 'failed';
+    existingEntitiesPath?: string | null;
+}
+/** What the user confirmed at the scope gate, which the CLI now shows. The wizard saves it, then generates. */
+export interface HandoffScope {
+    decisions: {
+        accepted: string[];
+        rejected: string[];
+    };
+    /** Components the cache check (finished and restored before the wizard started) found already generated. */
+    cachedNames: string[];
+}
+export declare function scopeFromHandoff(handoff: ImportHandoff): HandoffScope | null;
+export declare function stateFromHandoff(handoff: ImportHandoff): HandoffState;
+export type StartFromHandoff = {
+    ok: true;
+    handoff: ImportHandoff;
+    state: HandoffState;
+    scope: HandoffScope | null;
+} | {
+    ok: false;
+    error: string;
+};
+/** Reads the handoff the CLI passed. A missing or broken one is an error to show, never a guess at a start. */
+export declare function readHandoff(env?: NodeJS.ProcessEnv): StartFromHandoff;