@contentful/experience-design-system-cli 2.37.1-dev-build-dbc9f30e.0 → 2.37.1-dev-build-8b126ca1.0

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

@@ -0,0 +1,45 @@
+import type { ServerPreviewResponse } from '@contentful/experience-design-system-types';
+export declare class TimeoutError extends Error {
+    constructor(message?: string);
+}
+export type LivePreviewResult = {
+    generation: number;
+    response: ServerPreviewResponse | null;
+};
+export type RunLivePreviewOptions = {
+    sessionId: string;
+    tokensPath: string;
+    spaceId: string;
+    environmentId: string;
+    cmaToken: string;
+    host: string;
+    generation: number;
+    timeoutMs?: number;
+    /** When true and no components are accepted, preview an empty-but-present
+     *  components manifest so the server returns the full delete-all diff
+     *  (every existing component as `removed`) instead of rejecting an empty
+     *  manifest. Lets the final-review UI show what a push would delete. */
+    deleteAllComponents?: boolean;
+    /** Restrict the preview to these component keys (the operator's accepted
+     *  set). Undefined = all generated components in the session. An empty set
+     *  narrows to zero components — pair with `deleteAllComponents` to preview a
+     *  full delete. Lets the Finalize dialog show exactly what the accepted push
+     *  would delete, independent of the session's on-disk generated rows. */
+    acceptedKeys?: ReadonlySet<string>;
+};
+/**
+ * Pure async helper used by `useLivePreview` to re-fire `previewImport` after a
+ * FieldEditor save in the wizard's final-review step. A side-effect-bearing
+ * pure orchestrator that owns no React state.
+ *
+ * Skips silently (returns `{ response: null }`) when any of `spaceId`,
+ * `environmentId`, or `cmaToken` is missing — live preview is an enhancement
+ * and the caller treats `null` as a no-op. Throws on API errors so the caller
+ * (`useLivePreview`) can downgrade to local-only mode on 401/403 and log a
+ * warning otherwise. Wraps the API call in a timeout so a hung backend doesn't
+ * leave the spinner stuck.
+ *
+ * Does NOT run the second-pass seeding from `WizardApp.runPreview`; that's a
+ * one-shot wizard-step concern and would re-seed on every save.
+ */
+export declare function runLivePreview(opts: RunLivePreviewOptions): Promise<LivePreviewResult>;

package/dist/src/tui/import/steps/09-review/scroll-offset.d.ts

@@ -0,0 +1,30 @@
+/**
+ * Pure helper for computing the next scroll offset when the operator presses
+ * a navigation key inside a scrollable TUI panel (JSON view, rationale view,
+ * etc.). Extracted as a shared module so multiple panels can reuse the same
+ * scroll bindings without duplicating logic.
+ *
+ * Returns the new offset, or `null` if the input doesn't match any scroll
+ * binding (caller should NOT update state in that case).
+ *
+ * Supported bindings:
+ * - downArrow          → +1 line
+ * - upArrow            → -1 line
+ * - Ctrl+d             → +half-page (floor(panelHeight / 2))
+ * - Ctrl+u             → -half-page
+ * - PageDown           → +panelHeight
+ * - PageUp             → -panelHeight
+ * - G                  → jump to maxOffset
+ *
+ * `j`/`k` are intentionally not handled here because they are field-navigation
+ * keys in the editor. `g` (single-tap) and `gg` (double-tap → jump to 0) are handled separately
+ * by the caller via a pending-flag ref, since they need transient state.
+ */
+export type ScrollKeyState = {
+    upArrow?: boolean;
+    downArrow?: boolean;
+    pageUp?: boolean;
+    pageDown?: boolean;
+    ctrl?: boolean;
+};
+export declare function computeNextScrollOffset(current: number, input: string, key: ScrollKeyState, totalLines: number, panelHeight: number): number | null;

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

@@ -0,0 +1,26 @@
+import type { DatabaseSync } from 'node:sqlite';
+import type { HistorySnapshot } from './history.js';
+import type { CdfReviewEntry, ReviewComponentStatus, TokenReviewToken } from './types.js';
+export type ReviewSessionLoadResult<TExtra = undefined> = {
+    entries: CdfReviewEntry[];
+    tokens: TokenReviewToken[];
+    error: string | null;
+    extra?: TExtra;
+};
+export type ReviewSessionLoaderOptions<TExtra = undefined> = {
+    extractSessionId: string;
+    tokenSessionId?: string | null;
+    loadExtra?: (db: DatabaseSync, sessionId: string) => TExtra;
+    sortEntries: (entries: CdfReviewEntry[], extra: TExtra | undefined) => CdfReviewEntry[];
+};
+export declare function loadReviewSessionState<TExtra = undefined>({ extractSessionId, tokenSessionId, loadExtra, sortEntries, }: ReviewSessionLoaderOptions<TExtra>): ReviewSessionLoadResult<TExtra>;
+export declare function createReviewHistorySnapshot(components: CdfReviewEntry[], options?: {
+    autoRejected?: readonly string[];
+    undoSnapshot?: ReadonlyMap<string, ReviewComponentStatus> | null;
+}): HistorySnapshot;
+export type ReviewFinalizeCounts = {
+    accepted: number;
+    rejected: number;
+    unresolved: number;
+};
+export declare function finalizeReviewSession(extractSessionId: string, components: CdfReviewEntry[]): ReviewFinalizeCounts;

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

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

package/dist/src/tui/import/steps/09-review/token-suggestions.d.ts

@@ -0,0 +1,8 @@
+import type { CDFComponentEntry } from '@contentful/experience-design-system-types';
+import type { TokenPropSuggestion, TokenReviewToken } from './types.js';
+/**
+ * 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[];

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

@@ -0,0 +1,19 @@
+import type { CDFComponentEntry } from '@contentful/experience-design-system-types';
+export type ReviewComponentStatus = 'needs-review' | 'reviewed' | 'accepted' | 'rejected';
+export type CdfReviewEntry = {
+    key: string;
+    entry: CDFComponentEntry;
+    status: ReviewComponentStatus;
+};
+export type ReviewPanel = 'none' | 'prop-rationale' | 'component-rationale' | 'source' | 'token-review';
+export type TokenReviewToken = {
+    path: string;
+    kind: string;
+};
+export type TokenPropSuggestion = {
+    propName: string;
+    paths: string[];
+    suggested: string[];
+    allowed: string[];
+};
+export type PreviewAnnotation = 'new' | 'changed' | 'removed' | 'breaking';

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

@@ -0,0 +1,39 @@
+import type { ComponentTypeSummary } from '@contentful/experience-design-system-types';
+type FinalizePreviewStatus = 'idle' | 'running' | 'done' | 'error';
+export type UseFinalizePreviewOptions = {
+    /** True while the Finalize dialog is open. Toggling true (re)fires the preview. */
+    open: boolean;
+    extractSessionId: string | null;
+    tokensPath: string;
+    spaceId: string;
+    environmentId: string;
+    cmaToken: string;
+    host: string;
+    /** Component keys the operator has accepted; drives the scoped preview. */
+    acceptedKeys: ReadonlySet<string>;
+};
+export type UseFinalizePreviewReturn = {
+    status: FinalizePreviewStatus;
+    removed: ComponentTypeSummary[];
+    scrollOffset: number;
+    /** Adjust the removed-list scroll (clamped to the window). */
+    scrollBy: (delta: number) => void;
+};
+export type UseReviewFinalizePreviewOptions = Omit<UseFinalizePreviewOptions, 'acceptedKeys'> & {
+    components: ReadonlyArray<{
+        key: string;
+        status: string;
+    }>;
+};
+export declare function useReviewFinalizePreview({ components, ...options }: UseReviewFinalizePreviewOptions): UseFinalizePreviewReturn;
+/**
+ * Shared Finalize-dialog preview, used by both the composite and atomic
+ * generate-review steps.
+ *
+ * When the dialog opens it fires a preview scoped to the ACCEPTED set (so the
+ * result reflects exactly what the push does, independent of the session's
+ * not-yet-reclassified generated rows), tracks loading/error, and owns the
+ * scroll offset for the preview list.
+ */
+export declare function useFinalizePreview(opts: UseFinalizePreviewOptions): UseFinalizePreviewReturn;
+export {};

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

@@ -0,0 +1,39 @@
+import type { ServerPreviewResponse } from '@contentful/experience-design-system-types';
+export type UseLivePreviewOptions = {
+    enabled: boolean;
+    sessionId: string;
+    tokensPath: string;
+    spaceId: string;
+    environmentId: string;
+    cmaToken: string;
+    host: string;
+    onResult: (response: ServerPreviewResponse | null) => void;
+    debounceMs?: number;
+    /** Preview an empty-but-present CDF document (delete-all diff) when nothing
+     *  is accepted, so the final-review UI can show what a push would delete. */
+    deleteAllComponents?: boolean;
+};
+type LivePreviewStatus = 'idle' | 'running';
+export type UseLivePreviewReturn = {
+    trigger: () => void;
+    status: LivePreviewStatus;
+    disabled: boolean;
+};
+/**
+ * Hook that owns the post-save live-preview side effect for the wizard's
+ * final-review step. Centralizes:
+ *
+ * - 500ms debounce so rapid Ctrl+S spam collapses to a single API call.
+ * - Generation tag on every fire so a stale in-flight call's response is
+ *   discarded if a newer fire has already kicked off (in lieu of an
+ *   AbortController for v1).
+ * - Disable-for-session on 401/403: subsequent triggers no-op until the
+ *   wizard exits. One-line stderr warning. No modal, no re-prompt — the
+ *   operator is mid-edit and we must not interrupt the flow.
+ * - Status state for the sidebar spinner (`'idle' | 'running'`).
+ *
+ * Cred-missing / disabled / not-enabled cases short-circuit BEFORE the timer
+ * is set so we don't accumulate dead timers.
+ */
+export declare function useLivePreview(opts: UseLivePreviewOptions): UseLivePreviewReturn;
+export {};

package/dist/src/tui/import/steps/09-review/use-review-editor.d.ts

@@ -0,0 +1,47 @@
+import { type Dispatch, type SetStateAction } from 'react';
+import type { CdfReviewEntry, ReviewPanel, TokenPropSuggestion, TokenReviewToken } from './types.js';
+type UseReviewEditorOptions = {
+    components: CdfReviewEntry[];
+    selectedIdx: number;
+    extractSessionId: string;
+    availableTokens: TokenReviewToken[];
+    setComponents: Dispatch<SetStateAction<CdfReviewEntry[]>>;
+    pushHistorySnapshot: (entries: CdfReviewEntry[], label: string) => void;
+    onEditSaved: (entries: CdfReviewEntry[]) => void;
+    onTokenSaved: (entries: CdfReviewEntry[]) => void;
+};
+export type UseReviewEditorResult = {
+    panelOpen: ReviewPanel;
+    setPanelOpen: Dispatch<SetStateAction<ReviewPanel>>;
+    panelScrollOffset: number;
+    setPanelScrollOffset: Dispatch<SetStateAction<number>>;
+    jsonScrollOffset: number;
+    setJsonScrollOffset: Dispatch<SetStateAction<number>>;
+    textEntryActive: boolean;
+    setTextEntryActive: Dispatch<SetStateAction<boolean>>;
+    showJson: boolean;
+    setShowJson: Dispatch<SetStateAction<boolean>>;
+    showHiddenProps: boolean;
+    setShowHiddenProps: Dispatch<SetStateAction<boolean>>;
+    draftValue: string;
+    setDraftValue: Dispatch<SetStateAction<string>>;
+    saveError: string | null;
+    setSaveError: Dispatch<SetStateAction<string | null>>;
+    tokenReviewRow: number;
+    setTokenReviewRow: Dispatch<SetStateAction<number>>;
+    tokenReviewEditing: boolean;
+    setTokenReviewEditing: Dispatch<SetStateAction<boolean>>;
+    tokenReviewEditCursor: number;
+    setTokenReviewEditCursor: Dispatch<SetStateAction<number>>;
+    tokenReviewEditSelection: Set<string>;
+    setTokenReviewEditSelection: Dispatch<SetStateAction<Set<string>>>;
+    pendingGRef: {
+        current: boolean;
+    };
+    currentTokenSuggestions: () => TokenPropSuggestion[];
+    handleEditSave: () => void;
+    handleEditDiscard: () => void;
+    handleTokenEditSave: (suggestion: TokenPropSuggestion) => void;
+};
+export declare function useReviewEditor({ components, selectedIdx, extractSessionId, availableTokens, setComponents, pushHistorySnapshot, onEditSaved, onTokenSaved, }: UseReviewEditorOptions): UseReviewEditorResult;
+export {};

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

@@ -0,0 +1,25 @@
+import type { ComponentTypeSummary, ServerPreviewResponse } from '@contentful/experience-design-system-types';
+import type { PreviewAnnotation } from './types.js';
+import { type UseLivePreviewReturn } from './use-live-preview.js';
+export type UseReviewPreviewOptions = {
+    components: ReadonlyArray<{
+        key: string;
+    }>;
+    loading: boolean;
+    livePreview: boolean;
+    sessionId: string;
+    tokensPath: string;
+    spaceId: string;
+    environmentId: string;
+    cmaToken: string;
+    host: string;
+    deleteAllComponents?: boolean;
+    onResult?: (response: ServerPreviewResponse) => void;
+};
+export type UseReviewPreviewResult = {
+    previewAnnotations: Map<string, PreviewAnnotation>;
+    removedComponents: ComponentTypeSummary[];
+    livePreviewHook: UseLivePreviewReturn;
+    livePreviewSpinner: string;
+};
+export declare function useReviewPreview({ components, loading, livePreview, sessionId, tokensPath, spaceId, environmentId, cmaToken, host, deleteAllComponents, onResult, }: UseReviewPreviewOptions): UseReviewPreviewResult;

package/dist/src/tui/import/steps/09-review/use-review-session.d.ts

@@ -0,0 +1,65 @@
+import { type Dispatch, type SetStateAction } from 'react';
+import { type ComponentRationale, type ComponentReviewMetadata } from '@contentful/experience-design-system-backend-pipeline';
+import { type HistorySnapshot } from './history.js';
+import { type ReviewSessionLoadResult } from './session.js';
+import type { CdfReviewEntry, TokenReviewToken } from './types.js';
+type UseReviewSessionOptions<TExtra> = {
+    loadSession: () => ReviewSessionLoadResult<TExtra>;
+    tokensPath?: string;
+    onExtraLoaded?: (extra: TExtra | undefined) => void;
+};
+type UseReviewSessionResult<TExtra> = {
+    components: CdfReviewEntry[];
+    setComponents: Dispatch<SetStateAction<CdfReviewEntry[]>>;
+    loading: boolean;
+    loadError: string | null;
+    availableTokens: TokenReviewToken[];
+    reloadFromSave: () => ReviewSessionLoadResult<TExtra> | null;
+};
+export declare function useReviewSession<TExtra = undefined>({ loadSession, tokensPath, onExtraLoaded, }: UseReviewSessionOptions<TExtra>): UseReviewSessionResult<TExtra>;
+type UseReviewMetadataOptions = {
+    components: CdfReviewEntry[];
+    selectedIdx: number;
+    extractSessionId: string;
+};
+export declare function useReviewMetadata({ components, selectedIdx, extractSessionId }: UseReviewMetadataOptions): {
+    reviewMetadata: ComponentReviewMetadata | null;
+    componentRationale: ComponentRationale | null;
+};
+type UseReviewHistoryOptions = {
+    loading: boolean;
+    components: CdfReviewEntry[];
+    createSnapshot: (components: CdfReviewEntry[]) => HistorySnapshot;
+    applySnapshot: (snapshot: HistorySnapshot) => void;
+};
+export declare function useReviewHistory({ loading, components, createSnapshot, applySnapshot }: UseReviewHistoryOptions): {
+    historySeededRef: {
+        current: boolean;
+    };
+    pushHistorySnapshot: (entries: CdfReviewEntry[], label: string) => void;
+    handleUndo: () => void;
+    handleRedo: () => void;
+    resetHistory: (snapshot: HistorySnapshot) => void;
+};
+export type UseReviewFinalizeOptions = {
+    showFinalize: boolean;
+    extractSessionId: string;
+    tokensPath: string;
+    spaceId: string;
+    environmentId: string;
+    cmaToken: string;
+    host: string;
+    components: CdfReviewEntry[];
+    onFinalize: (accepted: number, rejected: number, unresolved: number) => void;
+};
+/**
+ * Shared by both the composite and atomic generate-review steps: the Finalize
+ * dialog's scoped preview (`useReviewFinalizePreview`) plus the confirm
+ * handler that reclassifies rejected/unresolved components and reports the
+ * final counts back to the wizard.
+ */
+export declare function useReviewFinalize({ showFinalize, extractSessionId, tokensPath, spaceId, environmentId, cmaToken, host, components, onFinalize, }: UseReviewFinalizeOptions): {
+    finalizePreview: import("./use-finalize-preview.js").UseFinalizePreviewReturn;
+    handleFinalizeConfirm: () => void;
+};
+export {};

package/dist/src/tui/import/steps/09-review/use-review-surface-state.d.ts

@@ -0,0 +1,12 @@
+import { type Dispatch, type SetStateAction } from 'react';
+export type UseReviewSurfaceStateResult = {
+    sidebarFocused: boolean;
+    setSidebarFocused: Dispatch<SetStateAction<boolean>>;
+    showFinalize: boolean;
+    setShowFinalize: Dispatch<SetStateAction<boolean>>;
+    showQuit: boolean;
+    setShowQuit: Dispatch<SetStateAction<boolean>>;
+    finalizeError: string | null;
+    setFinalizeError: Dispatch<SetStateAction<string | null>>;
+};
+export declare function useReviewSurfaceState(initialFinalizeError?: string | null): UseReviewSurfaceStateResult;

package/dist/src/tui/import/steps/10-flow/components/CustomPromptBanner.d.ts

@@ -0,0 +1,5 @@
+import React from 'react';
+export interface CustomPromptBannerProps {
+    generatePromptPath?: string;
+}
+export declare function CustomPromptBanner({ generatePromptPath }: CustomPromptBannerProps): React.ReactElement | null;

package/dist/src/tui/import/steps/10-flow/components/SpaceEnvironment.d.ts

@@ -0,0 +1,7 @@
+import React from 'react';
+type SpaceEnvironmentProps = {
+    spaceId: string;
+    environmentId: string;
+};
+export declare function SpaceEnvironment({ spaceId, environmentId }: SpaceEnvironmentProps): React.ReactElement;
+export {};

package/dist/src/tui/import/steps/10-flow/components/StepHeader.d.ts

@@ -0,0 +1,8 @@
+import React from 'react';
+type StepHeaderProps = {
+    stepNumber: number;
+    totalSteps: number;
+    title: string;
+};
+export declare function StepHeader({ stepNumber, totalSteps, title }: StepHeaderProps): React.ReactElement;
+export {};

package/dist/src/tui/import/steps/10-flow/flow/build-flow-start.d.ts

@@ -0,0 +1,21 @@
+import type { ImportHandoff } from '@contentful/experience-design-system-types/handoff';
+import type { ExtractionInput } from '../../06-extraction/types.js';
+import type { FlowStart } from './controller.js';
+interface SavedCredentials {
+    spaceId?: string;
+    environmentId?: string;
+    cmaToken?: string;
+    host?: string;
+}
+/**
+ * What the flow starts from. The credentials are the ones the user confirmed. When they skipped validation there are none
+ * to use, so the saved ones stand in, which is what the wizard did: it always read them from the store. The review's
+ * live preview and the push use them.
+ */
+export declare function buildFlowStart(input: {
+    extraction: ExtractionInput;
+    handoff: ImportHandoff;
+    saved?: SavedCredentials;
+    generatePromptPath?: string;
+}): FlowStart;
+export {};

package/dist/src/tui/import/steps/10-flow/flow/controller.d.ts

@@ -0,0 +1,65 @@
+import { type PreviewValidationError } from '@contentful/experience-design-system-backend-pipeline';
+import type { ImportHandoff } from '@contentful/experience-design-system-types/handoff';
+import { type PreviewDeps } from './preview.js';
+import { type PushDeps } from './push.js';
+import { type SaveDeps } from './save.js';
+import { type FlowPatch, type FlowState } from './types.js';
+/** What the flow starts from: what the earlier stages produced, and the user's saved settings. */
+export interface FlowStart {
+    handoff: ImportHandoff;
+    agent: string;
+    projectPath: string;
+    /** Where the files are saved by default. */
+    outDir: string;
+    rawTokensPath: string;
+    credentials: {
+        spaceId: string;
+        environmentId: string;
+        cmaToken: string;
+        host: string;
+    };
+    /** A custom prompt for `generate components`, shown as a warning above every step. */
+    generatePromptPath?: string;
+}
+/** The outside world the flow talks to besides the preview, push and save steps. */
+export interface FlowDeps {
+    preview: PreviewDeps;
+    push: PushDeps;
+    save: SaveDeps;
+    /** Reads the accepted components, for the cycle check at finalize. */
+    loadAcceptedComponents: (sessionId: string) => Array<{
+        key: string;
+        entry: unknown;
+    }>;
+    mkdir: (path: string) => Promise<void>;
+    detectSaveConflict: (path: string) => Promise<boolean>;
+    buildTimestampedSubdir: (path: string) => string;
+    rejectComponentsByName: (sessionId: string, names: string[]) => Promise<unknown>;
+    /** Writes one line of the wizard's step log. */
+    log: (entry: Record<string, unknown>) => void;
+    stderr: (text: string) => void;
+}
+export declare function startWizardLog(): void;
+export declare function realFlowDeps(): FlowDeps;
+/** The state the flow begins in, from what the earlier stages handed over. */
+export declare function initialFlowState(start: FlowStart): FlowState;
+/** What the log gets: the state change without the token, the document, or the whole of a large server response. */
+export declare function sanitizeForLog(partial: FlowPatch): Record<string, unknown>;
+/** The names of the components the errors are about, once each. */
+export declare function namesToSkip(errors: readonly PreviewValidationError[]): string[];
+export interface FlowController {
+    getState(): FlowState;
+    subscribe(listener: () => void): () => void;
+    finalize(accepted: number, rejected: number, unresolved: number): void;
+    submitPath(path: string): Promise<void>;
+    confirmPreview(acknowledgeBreakingChanges: boolean): void;
+    acknowledgeBreakingChanges(): void;
+    editDefinitions(): void;
+    skipValidationErrors(): Promise<void>;
+}
+/**
+ * The wizard's state machine, taken out of the screen so each transition can be tested without a terminal. It holds the
+ * state, applies the patches the steps return, and decides what runs next. It never exits the process: leaving is the
+ * screen's decision.
+ */
+export declare function createFlowController(start: FlowStart, deps: FlowDeps): FlowController;

package/dist/src/tui/import/steps/10-flow/flow/preview.d.ts

@@ -0,0 +1,56 @@
+import type { DatabaseSync } from 'node:sqlite';
+import { ApiError, patchReviewStateWithValidationErrors, type PreviewValidationError } from '@contentful/experience-design-system-backend-pipeline';
+import { type CDFDocument, type DTCGTokenEntry, type ServerPreviewResponse } from '@contentful/experience-design-system-types';
+import type { FlowPatch, FlowState } from './types.js';
+type PreviewClient = {
+    previewImport(cdf: CDFDocument): Promise<ServerPreviewResponse>;
+};
+/** The outside world `runPreview` talks to, so each branch can be tested without a database or a network. */
+export interface PreviewDeps {
+    createClient: (options: {
+        cmaToken: string;
+        spaceId: string;
+        environmentId: string;
+        host: string;
+    }) => PreviewClient;
+    openDb: () => DatabaseSync;
+    readTokens: (path: string) => Promise<DTCGTokenEntry[]>;
+    patchReviewState: typeof patchReviewStateWithValidationErrors;
+    verboseErrors: boolean;
+}
+export declare const realPreviewDeps: () => PreviewDeps;
+export interface RunPreviewInput {
+    state: Pick<FlowState, 'credentialsSkipped'>;
+    extractSessionId: string | null;
+    tokensPath: string;
+    spaceId: string;
+    environmentId: string;
+    cmaToken: string;
+    host: string;
+    /** Set when nothing was accepted, so the document is present but empty and the server shows what would be deleted. */
+    deleteAll: boolean;
+}
+/** What to do with a 422 from the preview: show the components that failed, or fall through to the generic error. */
+type Preview422Outcome = {
+    kind: 'validation-error';
+    errors: PreviewValidationError[];
+    missingNames: string[];
+} | {
+    kind: 'unparseable';
+    message: string;
+} | {
+    kind: 'not-422';
+};
+export declare function handlePreview422(err: ApiError, extractSessionId: string | null, patchFn: PreviewDeps['patchReviewState']): Promise<Preview422Outcome>;
+/** The patch to spread into any update that leaves the validation error step, so stale errors do not linger. */
+export declare function clearedValidationErrorState(): Pick<FlowState, 'previewValidationErrors' | 'previewValidationMissingNames'>;
+/**
+ * Loads what would be pushed and asks the server what that would change. Returns the patch the wizard applied: the
+ * preview gate, a terminal "done" when nothing would change, the validation error step for a 422, or an error.
+ *
+ * It also repairs two things the server's answer can reveal: components it says would be removed that are in fact local
+ * (the review dropped their CDF), and defaults it would change. Both are re-seeded from the response, and the preview is
+ * taken again.
+ */
+export declare function runPreview(input: RunPreviewInput, deps: PreviewDeps): Promise<FlowPatch>;
+export {};

package/dist/src/tui/import/steps/10-flow/flow/push.d.ts

@@ -0,0 +1,43 @@
+import { updateRun } from '@contentful/experience-design-system-backend-pipeline';
+import { type ApplyOperationResponse, type CDFDocument, type ServerPreviewResponse } from '@contentful/experience-design-system-types';
+import type { FlowPatch, FlowState } from './types.js';
+type PushClient = {
+    applyImport(cdf: CDFDocument, options: {
+        acknowledgeBreakingChanges: boolean;
+    }): Promise<ApplyOperationResponse>;
+    pollOperation(operationId: string, options: {
+        onProgress?: (operation: ApplyOperationResponse) => void;
+    }): Promise<ApplyOperationResponse>;
+};
+/** The outside world `runPush` talks to, so each branch can be tested without a network or a run history. */
+export interface PushDeps {
+    createClient: (options: {
+        cmaToken: string;
+        spaceId: string;
+        environmentId: string;
+        host: string;
+    }) => PushClient;
+    updateRun: typeof updateRun;
+    /** Where the wizard's step log goes. A log that cannot be written is reported on stderr and never stops the push. */
+    log: (entry: Record<string, unknown>) => void;
+    warn: (message: string) => void;
+    verboseErrors: boolean;
+}
+export declare const realPushDeps: (log: PushDeps["log"]) => PushDeps;
+export interface RunPushInput {
+    state: Pick<FlowState, 'credentialsSkipped' | 'lastRunId'>;
+    cdf: CDFDocument;
+    spaceId: string;
+    environmentId: string;
+    cmaToken: string;
+    host: string;
+    acknowledgeBreakingChanges: boolean;
+    preview?: ServerPreviewResponse | null;
+}
+/**
+ * Pushes the previewed document: the checks that refuse a push that cannot work, then the apply, polling its progress,
+ * and the result as the counts the done screen shows. `onPatch` receives the progress while it polls; the returned patch
+ * is where the flow ends up.
+ */
+export declare function runPush(input: RunPushInput, deps: PushDeps, onPatch: (patch: FlowPatch) => void): Promise<FlowPatch>;
+export {};

package/dist/src/tui/import/steps/10-flow/flow/save.d.ts

@@ -0,0 +1,50 @@
+import type { DatabaseSync } from 'node:sqlite';
+import { appendRun, buildSourceFingerprint } from '@contentful/experience-design-system-backend-pipeline';
+import { type CDFComponentEntry, type CDFDocument, type DTCGTokenEntry } from '@contentful/experience-design-system-types';
+import type { FlowPatch, FlowState } from './types.js';
+/** How long the confirmation of a written file stays up before the flow moves on to the preview. */
+export declare const SAVE_CONFIRMATION_DELAY_MS = 1000;
+/** The document written to `components.json`: the components and tokens as one schema-valid CDF. */
+export declare function buildSavedCDF(components: Array<{
+    key: string;
+    entry: CDFComponentEntry;
+}>, tokens: DTCGTokenEntry[], opts?: {
+    deleteAll?: boolean;
+}): CDFDocument;
+/** The outside world saving talks to, so each branch can be tested without a disk, a database or a clock. */
+export interface SaveDeps {
+    openDb: () => DatabaseSync;
+    readTokens: (path: string) => Promise<DTCGTokenEntry[]>;
+    writeFile: (path: string, contents: string) => Promise<void>;
+    appendRun: typeof appendRun;
+    buildSourceFingerprint: typeof buildSourceFingerprint;
+    sleep: (ms: number) => Promise<void>;
+    warn: (message: string) => void;
+}
+export declare const realSaveDeps: () => SaveDeps;
+export interface WriteFilesInput {
+    extractSessionId: string | null;
+    outDir: string;
+    tokenSessionId?: string | null;
+    tokensPath?: string;
+    skipGate?: boolean;
+    allowEmpty?: boolean;
+}
+/**
+ * Writes `components.json` to `outDir`. Returns the patch for the step after (the print gate, or nothing when the save
+ * is part of a push and goes straight on), or an error patch when the document could not be built or written.
+ * `onPatch` receives the "printing" step while it works.
+ */
+export declare function runPrintFiles(input: WriteFilesInput, deps: SaveDeps, onPatch: (patch: FlowPatch) => void): Promise<{
+    ok: true;
+    patch: FlowPatch;
+} | {
+    ok: false;
+    patch: FlowPatch;
+}>;
+export interface RecordRunInput {
+    state: Pick<FlowState, 'extractSessionId' | 'rawTokensPath' | 'projectPath' | 'generatedAcceptedCount' | 'generatedCount' | 'tokenCount' | 'tokenSessionId' | 'tokensPath' | 'agent' | 'generateSessionId'>;
+    savePath: string;
+}
+/** Records the run, so it can be found and pushed later. A run that cannot be recorded is warned about, never fatal. */
+export declare function recordRun(input: RecordRunInput, deps: SaveDeps): Promise<string | null>;