@contentful/experience-design-system-cli 2.38.1-dev-build-f59ff6e8.0 → 2.38.1-dev-build-1adffe40.0

package/dist/src/tui/import/steps/06-extraction/types.d.ts

@@ -0,0 +1,45 @@
+import type { ExtractionHandoff } from '@contentful/experience-design-system-types/handoff';
+export interface ExtractionInput {
+    projectPath: string;
+    /** Where the stage writes tokens.json and the other files. Defaults to `<projectPath>/.contentful`. */
+    outDir?: string;
+    /** Absolute source files from the path-validation step (collectFiles output). */
+    filePaths: string[];
+    /** Raw tokens file the user pointed at. Empty when the import does not generate tokens (components only). */
+    rawTokensPath: string;
+    /** Null when the user skipped credentials: no existing-entities fetch happens. */
+    credentials: {
+        spaceId: string;
+        environmentId: string;
+        cmaToken: string;
+        host: string;
+    } | null;
+    agent: string;
+    agentModel?: string;
+    promptOverrides: string[];
+    noCache: boolean;
+}
+type CompositionPhase = 'resolving' | 'cache-hit' | 'done' | `agent:${string}`;
+type JobStatus = 'idle' | 'running' | 'complete' | 'failed';
+/** Everything the extracting screen shows. One field per row. */
+export interface ExtractionProgress {
+    scan: {
+        scanned: number;
+        total: number | null;
+    } | null;
+    composition: CompositionPhase;
+    selection: 'running' | 'complete';
+    existingEntities: JobStatus;
+    tokens: JobStatus;
+}
+/** The label the error screen shows, as the wizard labelled it. */
+type ExtractionStepName = 'analyze extract' | 'selection agent' | 'generate tokens' | 'print tokens' | `${string} auth check`;
+export type ExtractionResult = {
+    ok: true;
+    extraction: ExtractionHandoff;
+} | {
+    ok: false;
+    step: ExtractionStepName;
+    message: string;
+};
+export {};

package/dist/src/tui/import/steps/06-extraction/use-extraction.d.ts

@@ -0,0 +1,14 @@
+import type { ExtractionInput, ExtractionProgress, ExtractionResult } from './types.js';
+export type ExtractionState = {
+    status: 'running';
+    progress: ExtractionProgress;
+} | {
+    status: 'done';
+    result: ExtractionResult;
+};
+/**
+ * Runs the extraction 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 useExtraction(input: ExtractionInput | undefined): ExtractionState | undefined;

package/dist/src/tui/import/steps/06-extraction/use-tokens-only.d.ts

@@ -0,0 +1,12 @@
+import { type TokensOnlyInput, type TokensOnlyResult } from './run-tokens-only.js';
+export type TokensOnlyState = {
+    status: 'running';
+} | {
+    status: 'done';
+    result: TokensOnlyResult;
+};
+/**
+ * Runs the tokens-only stage once for the given input. Passing nothing leaves it idle. A run that finishes after the
+ * input changed or the screen went away is ignored.
+ */
+export declare function useTokensOnly(input: TokensOnlyInput | undefined): TokensOnlyState | undefined;

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

@@ -0,0 +1,10 @@
+export interface CacheCheckInput {
+    sessionId: string;
+    tokensPath: string;
+    agent: string;
+    agentModel?: string;
+    promptOverrides: string[];
+    existingEntitiesPath: string | null;
+    noCache: boolean;
+}
+export declare function checkGenerationCache(input: CacheCheckInput): Promise<string[]>;

package/{legacy/dist/src/import/tui/scope-gate-columns.d.ts → dist/src/tui/import/steps/07-scope-gate/columns.d.ts}

@@ -1,11 +1,9 @@
-import type { Closure } from '../../analyze/composite-closure.js';
+import type { Closure } from './graph/composite-closure.js';
 /** Structural subset of ScopeComponent needed by these helpers. */
 export interface ScopeComponentLike {
     name: string;
 }
-export type Decision = 'accepted' | 'rejected' | 'undecided';
-export declare const SCOPE_GATE_MAIN_COLUMN_WIDTH = 54;
-export declare const ACCEPTED_COMPONENTS_COLUMN_WIDTH = 36;
+import type { Decision } from './types.js';
 export interface ScopeGatePanelLayout {
     height: number;
     mainVisibleCount: number;
@@ -34,3 +32,23 @@ export declare function computeCounters(components: ScopeComponentLike[], closur
     groups: number;
     total: number;
 };
+export declare function sideColumnLabelStyle(input: {
+    isCycle: boolean;
+    isSelected: boolean;
+    focused: boolean;
+}): {
+    nameColor: string | undefined;
+    nameBold: boolean;
+    nameInverse: boolean;
+    nameUnderline: boolean;
+    suffixColor: string | undefined;
+    suffixDim: boolean;
+    suffixInverse: boolean;
+    suffixUnderline: boolean;
+};
+export declare function computeColumnWindow(total: number, cursor: number, visibleCount: number): {
+    start: number;
+    end: number;
+    above: number;
+    below: number;
+};

package/dist/src/tui/import/steps/07-scope-gate/graph/fuzzy-search.d.ts

@@ -0,0 +1 @@
+export declare function fuzzyMatches(query: string, text: string): boolean;

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

@@ -0,0 +1,33 @@
+import type { CDFComponentEntry } from '@contentful/experience-design-system-types';
+import type { ScopeComponent } from '../types.js';
+import { type Closure, type ComponentGraphNode, type NodeStatus } from './composite-closure.js';
+import { type SlotCycle } from './cycle-detection.js';
+export interface ScopeGraph {
+    /** The slot dependency graph, one node per component. */
+    nodes: ComponentGraphNode[];
+    /** Every slot cycle. A graph that cannot be searched for cycles has none, as in legacy. */
+    cycles: SlotCycle[];
+    /** Names in at least one cycle. */
+    cycleParticipants: Set<string>;
+    /** For each cycle member, the whole set of members that has to be accepted or rejected with it. */
+    cycleUnits: Map<string, Set<string>>;
+    /** For each root, what it needs. A root with more than one node is a group. */
+    closures: Map<string, Closure>;
+}
+export interface SidebarItem {
+    key: string;
+    entry: CDFComponentEntry;
+    status: NodeStatus;
+}
+/** What the sidebar draws a row from: an entry standing in for the component (its slots are what matter), and its status. */
+export declare function sidebarItems(components: ScopeComponent[]): SidebarItem[];
+export declare function buildScopeGraph(components: ScopeComponent[]): ScopeGraph;
+/** Names that change when `target` is accepted. Pulls in everything it needs, whole cycles together. */
+export declare function acceptCascade(graph: ScopeGraph, target: string): string[];
+/** Rejecting rejects every ancestor and deselects the descendants. The screen asks first when it is 2 or more. */
+export declare function rejectCascade(graph: ScopeGraph, target: string): {
+    toReject: string[];
+    toDeselect: string[];
+};
+/** Everything reachable from the seeds, including the cycles they depend on. Used by "toggle all" and "accept non-flagged". */
+export declare function reachableCycleMembers(graph: ScopeGraph, seeds: string[]): string[];

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

@@ -0,0 +1,7 @@
+import type { ComponentGraphNode } from './composite-closure.js';
+export interface LineageParentEdge {
+    parent: string;
+    slotName: string;
+}
+export declare function findDirectParents(target: string, components: ComponentGraphNode[]): LineageParentEdge[];
+export declare function findAllAncestors(target: string, components: ComponentGraphNode[]): Set<string>;

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

@@ -0,0 +1,84 @@
+export type GateMode = 'help' | 'reject-prompt' | 'search' | 'cycles' | 'flags' | 'main';
+export interface KeyPress {
+    input: string;
+    upArrow?: boolean;
+    downArrow?: boolean;
+    return?: boolean;
+    escape?: boolean;
+    tab?: boolean;
+    shiftTab?: boolean;
+    ctrl?: boolean;
+}
+/** What legacy looked at besides the key and the open panel. */
+export interface GateContext {
+    focusedColumn: 'main' | 'added-components';
+    /** The layout has only the main column, so Tab has nowhere to go. */
+    singleColumn: boolean;
+    hasCycles: boolean;
+    /** Some component was flagged by the AI with a reason to show. */
+    hasFlagReasons: boolean;
+    /** A jump filter is on, so Esc clears it before it quits. */
+    jumpFilterActive: boolean;
+    /** Search text is set, so Esc clears it before it quits. */
+    searchActive: boolean;
+    /** The list in the focused column has no rows, so the arrows have nothing to move. */
+    focusedListEmpty: boolean;
+}
+export type GateAction = {
+    type: 'none';
+} | {
+    type: 'quit';
+} | {
+    type: 'confirm';
+} | {
+    type: 'close-help';
+} | {
+    type: 'answer-reject-prompt';
+    confirm: boolean;
+} | {
+    type: 'close-panel';
+} | {
+    type: 'close-search';
+} | {
+    type: 'submit-search';
+} | {
+    type: 'search-input';
+} | {
+    type: 'clear-jump-filter';
+} | {
+    type: 'clear-search';
+} | {
+    type: 'move';
+    delta: -1 | 1;
+} | {
+    type: 'jump-to-selected';
+} | {
+    type: 'accept';
+} | {
+    type: 'reject';
+} | {
+    type: 'toggle-all';
+} | {
+    type: 'accept-unflagged';
+} | {
+    type: 'toggle-group';
+} | {
+    type: 'expand-all';
+} | {
+    type: 'collapse-all';
+} | {
+    type: 'switch-column';
+    delta: -1 | 1;
+} | {
+    type: 'open-panel';
+    panel: 'cycles' | 'flags' | 'help' | 'search';
+} | {
+    type: 'toggle-dependencies';
+} | {
+    type: 'toggle-cycle-filter';
+} | {
+    type: 'toggle-jump-filter';
+} | {
+    type: 'toggle-view';
+};
+export declare function resolveKey(mode: GateMode, key: KeyPress, ctx: GateContext): GateAction;

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

@@ -0,0 +1,8 @@
+import type { ScopeGateLoad } from './types.js';
+/**
+ * Reads the components for the gate, once, before the screen renders. Replaces legacy's database read inside render
+ * (and its "remember the last list" workaround for the resize that happened after confirming): with nothing written
+ * until the wizard saves the decisions, the list cannot change under the screen.
+ * Uses `loadScopeComponents` from backend-pipeline, which is identical to legacy's.
+ */
+export declare function loadScopeGate(sessionId: string): ScopeGateLoad;

package/dist/src/tui/import/steps/07-scope-gate/panels/added-column.d.ts

@@ -0,0 +1,15 @@
+import React from 'react';
+import { type AddedComponentEntry } from '../columns.js';
+interface AddedColumnProps {
+    title: string;
+    width: number;
+    height: number;
+    entries: AddedComponentEntry[];
+    cursor: number;
+    focused: boolean;
+    aiFlaggedByKey?: Map<string, boolean>;
+    visibleCount: number;
+}
+/** The accepted components, cycle members first. Rejecting from here is the only decision it allows. */
+export declare function AddedColumn(props: AddedColumnProps): React.ReactElement;
+export {};

package/dist/src/tui/import/steps/07-scope-gate/panels/cycles-panel.d.ts

@@ -0,0 +1,8 @@
+import React from 'react';
+import type { SlotCycle } from '../graph/cycle-detection.js';
+interface CyclesPanelProps {
+    cycles: SlotCycle[];
+    cursor: number;
+}
+export declare function CyclesPanel({ cycles, cursor }: CyclesPanelProps): React.ReactElement;
+export {};

package/dist/src/tui/import/steps/07-scope-gate/panels/reject-prompt.d.ts

@@ -0,0 +1,5 @@
+import React from 'react';
+import type { PendingRejectCascade } from '../use-scope-gate.js';
+export declare function RejectPrompt({ pending }: {
+    pending: PendingRejectCascade;
+}): React.ReactElement;

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

@@ -0,0 +1,9 @@
+import React from 'react';
+import type { ScopeComponent, ScopeDecisions } from './types.js';
+interface ScopeGateScreenProps {
+    components: ScopeComponent[];
+    onConfirm: (decisions: ScopeDecisions) => void;
+    onQuit: () => void;
+}
+export declare function ScopeGateScreen(props: ScopeGateScreenProps): React.ReactElement;
+export {};

package/{legacy/dist/src/import/tui → dist/src/tui/import/steps/07-scope-gate/sidebar}/ai-flag.d.ts

@@ -3,4 +3,3 @@ export type AiFlaggable = {
     needsReview?: boolean;
 };
 export declare function isAiFlagged(row: AiFlaggable): boolean;
-export declare function isDefaultIncluded(row: AiFlaggable): boolean;

package/{legacy/dist/src/analyze/select/tui → dist/src/tui/import/steps/07-scope-gate/sidebar}/components/GotoBanner.d.ts

@@ -1,5 +1,5 @@
 import React from 'react';
-export interface GotoRow {
+interface GotoRow {
     label: string;
     jumpTarget: string;
     kind?: string;
@@ -29,3 +29,4 @@ export interface GotoBannerProps {
     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/{legacy/dist/src/analyze/select/tui → dist/src/tui/import/steps/07-scope-gate/sidebar}/components/GroupedSidebar.d.ts

@@ -1,8 +1,7 @@
 import React from 'react';
 import type { CDFComponentEntry } from '@contentful/experience-design-system-types';
-import { type ComponentGraphNode, type NodeStatus } from '../../../composite-closure.js';
-import type { RenderStatus } from '../../../issue-inheritance.js';
-import type { PreviewAnnotation } from '../../types.js';
+import { type ComponentGraphNode, type NodeStatus } from '../../graph/composite-closure.js';
+import type { PreviewAnnotation, RenderStatus } from '../types.js';
 export interface GroupedSidebarItem {
     key: string;
     entry: CDFComponentEntry;
@@ -34,6 +33,7 @@ export interface GroupedSidebarProps {
     visibleRows?: VisibleRow[];
     graph: ComponentGraphNode[];
     filterVisibleKeys?: Set<string>;
+    emptyMessage?: string;
 }
 type RowKind = 'cycle' | 'empty' | 'group-root' | 'group-child' | 'standalone' | 'flat' | 'flat-header';
 export interface VisibleRow {
@@ -57,38 +57,5 @@ export declare function buildVisibleRows(props: {
     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/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/{legacy/dist/src/tui → dist/src/tui/import/steps/07-scope-gate/sidebar/components}/windowed-panel.d.ts

@@ -25,12 +25,10 @@ export interface FixedPanelProps {
 export declare function FixedPanel({ width, height, minHeight, focused, borderStyle, borderColor, paddingLeft, clipOverflow, children, }: FixedPanelProps): ReactElement;
 /** 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 WindowedPanelHeader({ title, width, focused, }: {
-    title: string;
-    width: number;
-    focused: boolean;
+export declare function WindowFooter({ above, below }: {
+    above: number;
+    below: number;
 }): ReactElement;
-export declare function formatWindowIndicator(direction: WindowDirection, count: number): string;
 export declare function WindowIndicator({ direction, count }: {
     direction: WindowDirection;
     count: number;

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

@@ -1,2 +1,2 @@
-import type { Closure } from '../../analyze/composite-closure.js';
+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/lineage-layout.d.ts

@@ -0,0 +1,32 @@
+/**
+ * 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;
+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 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/{legacy/dist/src/import/tui → dist/src/tui/import/steps/07-scope-gate/sidebar}/sidebar-help.d.ts

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

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

@@ -1,5 +1,5 @@
-import type { ComponentGraphNode, Closure } from '../../analyze/composite-closure.js';
-import { type GroupedSidebarItem } from '../../analyze/select/tui/components/GroupedSidebar.js';
+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';

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

@@ -11,6 +11,10 @@ export declare function computeFilterKeys(input: {
     filters: Iterable<FilterCategory>;
     data: FilterDataSources;
 }): Set<string> | undefined;
+export declare function describeEmptyFilter(input: {
+    filters: Iterable<FilterCategory>;
+    slotDependencies?: boolean;
+}): 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';

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,27 @@
+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;
+} | {
+    status: 'confirmed';
+    decisions: ScopeDecisions;
+    cachedNames: Promise<string[]>;
+};
+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,77 @@
+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[];
+    emptyMessage: string | undefined;
+    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 {};