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

package/dist/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@contentful/experience-design-system-cli",
-  "version": "2.38.1-dev-build-6d903339.0",
+  "version": "2.38.1-dev-build-962dbe22.0",
   "description": "Contentful Experiences design system import CLI",
   "license": "MIT",
   "type": "module",

package/dist/src/commands/import-options.d.ts

@@ -1,12 +1,10 @@
 export interface ImportOptions {
     agent?: string;
     prompt: string[];
-    cache: boolean;
 }
 interface RawImportOptions {
     agent?: string;
     prompt?: string[];
-    cache?: boolean;
 }
 export declare function toImportOptions(raw: RawImportOptions): ImportOptions;
 export {};

package/dist/src/tui/debug-prune.d.ts

@@ -0,0 +1,12 @@
+export type PruneResult = {
+    logs: number;
+    folders: number;
+};
+/**
+ * Deletes the debug logs under `<base>/.contentful` that are older than `retentionDays`. It only looks at `.md` files
+ * inside the `debug` folder of a session folder, so nothing the import produced or the user put there is touched. A file
+ * that cannot be read or deleted is skipped: this runs at startup and must never get in the user's way. A folder the
+ * deletion left empty is removed too, up to the session folder; one that still holds anything stays. Returns how many
+ * logs and folders it deleted.
+ */
+export declare function pruneExpiredLogs(base: string, retentionDays: number, now?: number): Promise<PruneResult>;

package/dist/src/tui/debug-store.d.ts

@@ -1,6 +1,23 @@
 type Status = 'success' | 'error';
 type ExitMethod = 'saved' | 'discarded' | 'crashed';
-export declare function currentDebugSessionDir(): string;
+export declare function currentDebugSessionDir(): string | undefined;
+/** This terminal session's folder, `<base>/.contentful/<session>/`, or undefined until it is known. */
+export declare function currentSessionDir(): string | undefined;
+/**
+ * Starts this terminal session's folder in `base`. The base directory setting being saved passes `replace` so the new
+ * location wins; the import passes nothing and only starts a session when none exists yet. Fail-open like the rest of
+ * the logger.
+ */
+export declare function startDebugSessionIn(base: string, { replace }?: {
+    replace?: boolean | undefined;
+}): Promise<void>;
+/**
+ * Where this import run writes everything it produces (tokens.json, .existing-entities.json, components.json): a new
+ * `dsi-import-N` folder in this session's folder, next to the debug logs. The session is started here, and waited for,
+ * so the answer does not depend on how quickly the boot-time start finished. Without a session (Debug Mode off, or a
+ * folder that cannot be created) the files stay in `<project>/.contentful`, as before.
+ */
+export declare function startImportRun(projectPath: string): Promise<string>;
 export declare function startDebugRun({ flow, step, menuOption, inputs, }: {
     flow: string;
     step: string;

package/dist/src/tui/help/file-locations.d.ts

@@ -0,0 +1,23 @@
+export interface FileLocationInput {
+    /** The Root Project Directory from Settings > Configuration > Project. Empty when not set. */
+    contentfulBaseDir: string;
+    /** Whether Debug Mode is on. Debug logs and the per-run folders only exist while it is. */
+    debugModeEnabled: boolean;
+    /** This terminal session's folder, once it has started. */
+    currentSessionDir: string | undefined;
+}
+export interface FileLocations {
+    debugLogs: string;
+    importFiles: string;
+}
+/**
+ * Where the CLI writes the files a user goes looking for, from the settings that decide it (see `startImportRun`).
+ *
+ * With Debug Mode on, everything goes in this terminal session's folder, `<base>/.contentful/<date>-session-N/`:
+ * the debug logs in `debug/` and, for each import, a `dsi-import-N/` folder with `tokens.json` and `components.json`.
+ * `<base>` is the Root Project Directory, or the project being imported when none is set. With Debug Mode off there is
+ * no session folder and no logs, and the files go to `<project>/.contentful/`.
+ *
+ * Names that are only known when a session or an import starts are shown as patterns, never guessed.
+ */
+export declare function describeFileLocations({ contentfulBaseDir, debugModeEnabled, currentSessionDir, }: FileLocationInput): FileLocations;

package/dist/src/tui/home/home.theme.d.ts

@@ -1,11 +1,3 @@
-export declare const PALETTE: {
-    readonly accent: "#1773EB";
-    readonly success: "#00C459";
-    readonly error: "#E44F20";
-    readonly warning: "#FFDA00";
-    readonly muted: "#8B8D91";
-    readonly border: "#C4D1DE";
-};
 export declare function brandBar(width: number, ramp?: readonly string[]): {
     text: string;
     color: string;

package/dist/src/tui/import/shared/gate-step/gate-step.d.ts

@@ -1,4 +1,5 @@
 import React from 'react';
+import { type StepHeaderProps } from '@tui/shared/components/StepHeader.js';
 interface GateStepProps {
     message: string;
     onContinue: () => void;
@@ -9,6 +10,7 @@ interface GateStepProps {
     skipLabel?: string;
     onSkip?: () => void;
     intent?: 'success' | 'error';
+    step?: StepHeaderProps['step'];
 }
-export declare function GateStep({ message, onContinue, onQuit, summary, context, continueLabel, skipLabel, onSkip, intent, }: GateStepProps): React.ReactElement;
+export declare function GateStep({ message, onContinue, onQuit, summary, context, continueLabel, skipLabel, onSkip, intent, step, }: GateStepProps): React.ReactElement;
 export {};

package/dist/src/tui/import/shared/index.d.ts

@@ -1,3 +1,4 @@
 export { ErrorStep } from './error-step/error-step.js';
 export { GateStep } from './gate-step/gate-step.js';
+export { OverviewBox, type OverviewStep } from './overview-box/overview-box.js';
 export { RunningStep } from './running-step/running-step.js';

package/dist/src/tui/import/shared/overview-box/overview-box.d.ts

@@ -0,0 +1,10 @@
+import React from 'react';
+export interface OverviewStep {
+    description: string;
+    /** Whether the step uses the user's local AI agent. */
+    ai: boolean;
+}
+/** The framed list of the steps an import goes through, with the AI disclosure under it. Shown by the intro screens. */
+export declare function OverviewBox({ steps }: {
+    steps: readonly OverviewStep[];
+}): React.ReactElement;

package/dist/src/tui/import/shared/running-step/logic.d.ts

@@ -9,4 +9,3 @@ export interface RunningLine {
 }
 export declare function progressPercent(progress: Progress): number;
 export declare function formatElapsed(totalSeconds: number): string;
-export declare function stepLabel(stepNumber: number, totalSteps: number, title: string): string;

package/dist/src/tui/import/shared/running-step/running-step.d.ts

@@ -1,11 +1,10 @@
 import React from 'react';
 import { type RunningLine } from './logic.js';
+import type { ImportStepId } from '@tui/shared/components/StepHeader.js';
 interface RunningStepProps {
-    stepNumber: number;
-    totalSteps: number;
-    title: string;
+    step: ImportStepId;
     description: string;
     lines?: readonly RunningLine[];
 }
-export declare function RunningStep({ stepNumber, totalSteps, title, description, lines, }: RunningStepProps): React.ReactElement;
+export declare function RunningStep({ step, description, lines, }: RunningStepProps): React.ReactElement;
 export {};

package/dist/src/tui/import/steps/00-preflight/controls.d.ts

@@ -0,0 +1,17 @@
+import { type ImportTarget } from './logic.js';
+export declare const PREFLIGHT_CONTROLS: readonly [{
+    readonly keys: "↑/↓";
+    readonly label: "Choose";
+}, {
+    readonly keys: "Enter";
+    readonly label: "Continue";
+}, {
+    readonly keys: "Esc";
+    readonly label: "Back to menu";
+}];
+export declare function usePreflightControls(handlers: {
+    focus: number;
+    onFocus: (focus: number) => void;
+    onChoose: (target: ImportTarget) => void;
+    onQuit: () => void;
+}): void;

package/dist/src/tui/import/steps/00-preflight/logic.d.ts

@@ -0,0 +1,45 @@
+import type { OverviewStep } from '../../shared/index.js';
+export type ImportTarget = 'both' | 'tokens' | 'components';
+export declare const IMPORT_TARGET_OPTIONS: ReadonlyArray<{
+    target: ImportTarget;
+    label: string;
+}>;
+export declare function overviewFor(target: ImportTarget): readonly OverviewStep[];
+export type ImportStepId = 'project' | 'token-file' | 'path-validation' | 'credentials' | 'component-extraction' | 'token-generation' | 'scope-gate' | 'generation' | 'review' | 'save-push';
+export declare function stepsFor(target: ImportTarget): readonly ImportStepId[];
+export interface InputAnswers {
+    projectPath?: string;
+    tokensPath?: string;
+    scannedFiles?: string[];
+}
+/**
+ * The input screen to show: the first step of this mode whose answer is still missing, or 'credentials' once every
+ * earlier one is answered. A mode never shows a screen it does not list, so skipping one needs no special case.
+ */
+export declare function currentInputStep(target: ImportTarget, answers: InputAnswers): Extract<ImportStepId, 'project' | 'token-file' | 'path-validation' | 'credentials'>;
+/**
+ * What Back from `current` does: leave for the preflight when it is the first screen of the mode, otherwise clear the
+ * previous step's answer so that screen shows again.
+ */
+export declare function goBack(target: ImportTarget, current: ImportStepId, answers: InputAnswers): {
+    to: 'preflight';
+} | {
+    to: 'step';
+    answers: InputAnswers;
+};
+/**
+ * Where a run writes its files when it has no project to put them in: the Root Project Directory setting if there is
+ * one, otherwise the folder the token file is in. Components runs always have a project and use it.
+ */
+export declare function runBaseDir(input: {
+    projectPath?: string;
+    tokensPath?: string;
+    configuredBaseDir?: string;
+}): string;
+interface FocusKey {
+    upArrow: boolean;
+    downArrow: boolean;
+}
+/** The option focused after a key: arrows move through the list and wrap around. */
+export declare function moveFocus(focus: number, key: FocusKey, count: number): number;
+export {};

package/dist/src/tui/import/steps/00-preflight/screen.d.ts

@@ -0,0 +1,8 @@
+import React from 'react';
+import { type ImportTarget } from './logic.js';
+interface PreflightScreenProps {
+    onChoose: (target: ImportTarget) => void;
+    onQuit: () => void;
+}
+export declare function PreflightScreen({ onChoose, onQuit }: PreflightScreenProps): React.ReactElement;
+export {};

package/dist/src/tui/import/steps/01-welcome/controls.d.ts

@@ -1,8 +1,11 @@
 export declare const WELCOME_CONTROLS: readonly [{
     readonly keys: "Enter";
     readonly label: "Continue";
+}, {
+    readonly keys: "Ctrl+D";
+    readonly label: "Clear";
 }, {
     readonly keys: "Esc";
-    readonly label: "Back to menu";
+    readonly label: "Back";
 }];
 export declare function useWelcomeControls(onQuit: () => void): void;

package/dist/src/tui/import/steps/02-token-input/controls.d.ts

@@ -1,6 +1,9 @@
 export declare const TOKEN_INPUT_CONTROLS: readonly [{
     readonly keys: "Enter";
     readonly label: "Continue";
+}, {
+    readonly keys: "Ctrl+D";
+    readonly label: "Clear";
 }, {
     readonly keys: "Esc";
     readonly label: "Back";

package/dist/src/tui/import/steps/03-path-validation/helpers/scan-files.d.ts

@@ -1,10 +1,2 @@
-import { collectFiles } from '@contentful/experience-design-system-backend-pipeline';
-import type { FileCounts as LocalFileCounts, ScanResult } from '../logic.js';
-type CollectedFilesOutcome = ReturnType<typeof collectFiles>;
-type PipelineFileCounts = Extract<CollectedFilesOutcome, {
-    ok: true;
-}>['result']['counts'];
+import type { ScanResult } from '../logic.js';
 export declare function scanFiles(directory: string): ScanResult;
-export declare function toScanResult(outcome: CollectedFilesOutcome): ScanResult;
-export declare function foldSvelteAndMdIntoOther(counts: PipelineFileCounts): LocalFileCounts;
-export {};

package/dist/src/tui/import/steps/03-path-validation/logic.d.ts

@@ -32,12 +32,14 @@ interface Key {
     escape: boolean;
     return: boolean;
 }
-export declare function emptyCounts(): FileCounts;
-export declare function addFile(counts: FileCounts, fileName: string): FileCounts;
-export declare function mergeCounts(a: FileCounts, b: FileCounts): FileCounts;
-export declare function failureFromErrorCode(code: string | undefined): ScanFailureCode;
 export declare function describeFailure(failure: ScanFailureCode, path: string): FailureMessage;
-export declare function summarize(counts: FileCounts): Summary;
+/**
+ * The scan result as rows and a warning. When the import does not generate tokens (components only), `.json` files are
+ * not design tokens here, so the row says they are ignored and the warnings do not mention tokens.
+ */
+export declare function summarize(counts: FileCounts, { hasTokens }?: {
+    hasTokens?: boolean;
+}): Summary;
 export declare function phaseOf(scan: ScanResult | undefined): PathPhase;
 export declare function keyAction(phase: PathPhase, input: string, key: Key): KeyAction | undefined;
 export {};

package/dist/src/tui/import/steps/03-path-validation/screen.d.ts

@@ -7,6 +7,8 @@ interface PathValidationScreenProps {
     }) => void;
     onChangePath: () => void;
     onBack: () => void;
+    /** False when the import does not generate tokens, so `.json` files are not described as design tokens. */
+    hasTokens?: boolean;
 }
-export declare function PathValidationScreen({ projectPath, onConfirm, onChangePath, onBack, }: PathValidationScreenProps): React.ReactElement;
+export declare function PathValidationScreen({ projectPath, onConfirm, onChangePath, onBack, hasTokens, }: PathValidationScreenProps): React.ReactElement;
 export {};

package/dist/src/tui/import/steps/04-credentials/logic.d.ts

@@ -1,14 +1,11 @@
-export declare const FIELDS: readonly ["spaceId", "environmentId", "cmaToken", "host"];
+declare const FIELDS: readonly ["spaceId", "environmentId", "cmaToken", "host"];
 export type CredentialField = (typeof FIELDS)[number];
 export type CredentialValues = Record<CredentialField, string>;
-interface Key {
-    escape: boolean;
-    tab: boolean;
-    ctrl: boolean;
-}
-export type KeyAction = 'back' | 'next-field' | 'skip' | null;
-export declare function keyAction(input: string, key: Key): KeyAction;
-export declare function nextField(field: CredentialField): CredentialField;
+/**
+ * Why the space is asked for. Components are looked up in it before they are generated, so that is part of the reason
+ * unless the import only generates tokens, which has nothing to look up.
+ */
+export declare function credentialsPurpose(tokensOnly: boolean): string;
 export declare function normalize(values: CredentialValues): CredentialValues;
 export declare function missingField(values: CredentialValues): boolean;
 export declare function isUnchanged(current: CredentialValues, initial: CredentialValues): boolean;

package/dist/src/tui/import/steps/04-credentials/screen.d.ts

@@ -12,6 +12,8 @@ interface CredentialsScreenProps {
     onBack: () => void;
     initial?: Partial<CredentialValues>;
     validate?: (values: CredentialValues) => Promise<ValidationResult>;
+    /** The import only generates tokens, so there are no components to look up in the space. */
+    tokensOnly?: boolean;
 }
-export declare function CredentialsScreen({ onDone, onBack, initial, validate, }: CredentialsScreenProps): React.ReactElement;
+export declare function CredentialsScreen({ onDone, onBack, initial, validate, tokensOnly, }: CredentialsScreenProps): React.ReactElement;
 export {};

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

@@ -4,13 +4,11 @@ import type { ExtractionProgress } from './types.js';
 export type ProgressEvent = ExtractAndComposeProgress;
 /**
  * Every job the stage will run starts on the first frame, so no row appears later as a surprise. A job that does not
- * apply stays 'idle' and has no row: existing entities need credentials, token definitions need a raw tokens file, and
- * reused tokens are already complete.
+ * apply stays 'idle' and has no row: existing entities need credentials, and token definitions need a raw tokens file.
  */
 export declare function initialProgress(input: {
     hasCredentials: boolean;
     hasRawTokens: boolean;
-    reuseTokens: boolean;
 }): ExtractionProgress;
 export declare function applyProgressEvent(progress: ExtractionProgress, event: ProgressEvent): ExtractionProgress;
 /** The rows the screen shows, in the order the wizard showed them. Rows that do not apply are left out. */
@@ -20,19 +18,6 @@ export declare function progressRows(progress: ExtractionProgress, agent: string
 }>;
 /** True when every job is already done, so the screen would only flash. The wizard shows nothing in this case. */
 export declare function isFullCacheHit(progress: ExtractionProgress): boolean;
-/**
- * The wizard's step counts: three fixed steps, one more when there is a token stage, two more when components are
- * imported, and one more when the tokens can be mapped (not known yet at this stage, so it adds nothing here).
- * Extraction is step 2 when there is a token stage, otherwise step 1.
- */
-export declare function stepNumbers(input: {
-    hasRawTokens: boolean;
-    skipComponents?: boolean;
-    mapTokensEligible?: boolean | null;
-}): {
-    stepNumber: number;
-    totalSteps: number;
-};
 export declare function noComponentsMessage(projectPath: string): string;
 export declare function agentAuthMessage(agent: string, status: 'not-found' | 'unauthenticated'): string;
 /**

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

@@ -0,0 +1,31 @@
+import { checkAgentAuth, runGenerateTokensSession } from '@contentful/experience-design-system-backend-pipeline';
+export interface TokensOnlyInput {
+    rawTokensPath: string;
+    /** Where tokens.json is written: this import run's folder. */
+    outDir: string;
+    agent: string;
+    agentModel?: string;
+    promptOverrides: string[];
+    noCache: boolean;
+}
+export type TokensOnlyResult = {
+    ok: true;
+    tokensPath: string;
+    tokenSessionId: string | null;
+    tokenCount: number;
+} | {
+    ok: false;
+    step: 'generate tokens' | `${string} auth check`;
+    message: string;
+};
+/** The outside world the stage talks to, so it can be tested without an agent. */
+export interface TokensOnlyDeps {
+    checkAgentAuth: typeof checkAgentAuth;
+    runGenerateTokensSession: typeof runGenerateTokensSession;
+}
+/**
+ * The extraction stage for an import that only generates tokens: the same auth check and token generation the full stage
+ * runs, without scanning components, composing them or selecting. The full stage fails when it finds no components, so it
+ * cannot be used for this.
+ */
+export declare function runTokensOnly(input: TokensOnlyInput, deps?: TokensOnlyDeps): Promise<TokensOnlyResult>;

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

@@ -3,8 +3,6 @@ import type { ExtractionProgress } from './types.js';
 interface ExtractionScreenProps {
     progress: ExtractionProgress;
     agent: string;
-    stepNumber: number;
-    totalSteps: number;
 }
-export declare function ExtractionScreen({ progress, agent, stepNumber, totalSteps, }: ExtractionScreenProps): React.ReactElement;
+export declare function ExtractionScreen({ progress, agent }: ExtractionScreenProps): React.ReactElement;
 export {};

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

@@ -1,13 +1,12 @@
-import type { ExtractionHandoff, ImportHandoff } from '@contentful/experience-design-system-types/handoff';
-export type TokenStrategy = ImportHandoff['tokens']['strategy'];
+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 (always set: v2 asks for one). */
+    /** Raw tokens file the user pointed at. Empty when the import does not generate tokens (components only). */
     rawTokensPath: string;
-    /** From the token reuse step. 'reuse' skips token generation entirely. */
-    tokenStrategy: TokenStrategy;
     /** Null when the user skipped credentials: no existing-entities fetch happens. */
     credentials: {
         spaceId: string;

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

@@ -7,11 +7,4 @@ export interface CacheCheckInput {
     existingEntitiesPath: string | null;
     noCache: boolean;
 }
-/**
- * Runs the generation cache check in-process while the scope gate is open.
- * Restores cached CDF entries into the pipeline database as a side-effect so
- * the generate run that follows can skip them. A failed check is
- * indistinguishable from "nothing cached", as in legacy. INTEG-5050 tracks
- * surfacing it.
- */
 export declare function checkGenerationCache(input: CacheCheckInput): Promise<string[]>;

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

@@ -4,8 +4,6 @@ export interface ScopeComponentLike {
     name: string;
 }
 import type { Decision } from './types.js';
-export declare const SCOPE_GATE_MAIN_COLUMN_WIDTH = 54;
-export declare const ACCEPTED_COMPONENTS_COLUMN_WIDTH = 36;
 export interface ScopeGatePanelLayout {
     height: number;
     mainVisibleCount: number;

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

@@ -1,3 +1 @@
 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/dist/src/tui/import/steps/07-scope-gate/graph/lineage.d.ts

@@ -3,27 +3,5 @@ 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/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/dist/src/tui/import/steps/07-scope-gate/sidebar/components/GroupedSidebar.d.ts

@@ -33,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 {
@@ -56,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/windowed-panel.d.ts

@@ -25,6 +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 WindowFooter({ above, below }: {
+    above: number;
+    below: number;
+}): ReactElement;
 export declare function WindowIndicator({ direction, count }: {
     direction: WindowDirection;
     count: number;

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

@@ -1,10 +1,3 @@
-/** 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
@@ -12,23 +5,6 @@ export declare const MIN_PANEL_ROWS = 4;
  * 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;
@@ -37,18 +13,6 @@ export interface LineageLayoutInput {
     /** 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;

package/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/use-scope-gate.d.ts

@@ -26,6 +26,7 @@ export declare function useScopeGate({ components, onConfirm, onQuit }: UseScope
     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">;