@detergent-software/atk 8.9.0-dev.3 → 8.9.0-dev.30

package/build/hooks/usePublishState.js

@@ -1,588 +1,105 @@
-import { rm } from 'node:fs/promises';
-import { useEffect, useReducer, useRef } from 'react';
-import { createInitialState, isBatch, runPublishStep, splitList, } from '../lib/publish-flow.js';
-import { bumpVersion, isOrgScopedTarget } from '../lib/publisher.js';
-import { parseReviewersInput } from '../lib/reviewers.js';
-export { createInitialState, isBatch } from '../lib/publish-flow.js';
-export function publishReducer(state, action) {
+import { useEffect, useRef, useState } from 'react';
+import { createInitialState } from '../lib/publish-flow.js';
+import { promptValue, runPublish } from '../lib/publish-run.js';
+/** Move the tools prompt's cursor over its `count` rows, wrapping at either end, or tick or untick a tool. */
+export function toolPickerReducer(picker, action) {
     switch (action.type) {
-        case 'BUMP_DONE': {
-            const bumped = {
-                ...state,
-                errorMessage: action.message ? action.message : state.errorMessage,
-                resolvedVersion: action.version,
-                target: action.updatedTarget,
-            };
-            return action.message ? { ...bumped, phase: 'error' } : advanceToPlan(bumped);
-        }
-        case 'CONFIRM_PROMPT_TOOLS': {
-            if (state.selectedPromptTools.length === 0)
-                return state;
-            const updatedToolsTarget = state.target
-                ? {
-                    ...state.target,
-                    data: { ...state.target.data, tools: state.selectedPromptTools },
-                }
-                : undefined;
-            return {
-                ...state,
-                phase: phaseAfterMetadata(updatedToolsTarget),
-                target: updatedToolsTarget,
-            };
-        }
-        case 'DETECT_DONE':
-            if (action.target.type === 'bundle' && state.entries.length > 0) {
-                return {
-                    ...state,
-                    errorMessage: 'A bundle is published on its own. Remove --with, and publish its new assets first.',
-                    phase: 'error',
-                    target: action.target,
-                };
-            }
-            return {
-                ...state,
-                phase: 'validating',
-                target: action.target,
-            };
-        case 'ENTRIES_CHECKED':
-            return advanceToPlan({ ...state, entries: action.entries });
-        case 'ENTRIES_LOADED':
-            return { ...state, entries: action.entries };
-        case 'ERROR':
-            return {
-                ...state,
-                errorCode: action.code,
-                errorCommand: action.command,
-                errorHint: action.hint,
-                errorMessage: action.message,
-                phase: 'error',
-            };
-        case 'INSTALL_DONE':
-            return { ...state, phase: 'done' };
-        case 'PLAN_DONE': {
-            // dry-run always shows the dry-run result; --yes / non-TTY skip the confirm prompt
-            // and proceed directly to publishing.
-            let nextPhase;
-            if (state.flags.dryRun) {
-                nextPhase = 'dry-run-result';
-            }
-            else if (state.nonInteractive) {
-                nextPhase = 'publishing';
-            }
-            else {
-                nextPhase = 'confirm-publish';
-            }
-            return {
-                ...state,
-                manifestDiff: action.manifestDiff,
-                phase: nextPhase,
-                plan: action.plan,
-            };
-        }
-        case 'PUBLISH_DONE': {
-            const nextPhase = state.isRawPublish ? 'installing' : 'done';
-            return {
-                ...state,
-                phase: nextPhase,
-                publishResult: action.result,
-            };
-        }
-        case 'PUBLISH_PROGRESS':
-            return { ...state, progressMessage: action.message };
-        case 'RAW_DETECT_DONE':
-            return {
-                ...state,
-                authorValue: action.authorValue,
-                isRawPublish: true,
-                orgValue: action.orgValue,
-                phase: 'gathering-metadata',
-                rawDetection: action.rawDetection,
-                toolsDetected: action.toolsDetected,
-            };
-        case 'RAW_DETECT_DONE_NON_INTERACTIVE':
-            return {
-                ...state,
-                isRawPublish: true,
-                phase: 'validating',
-                rawDetection: action.rawDetection,
-                target: action.target,
-            };
-        case 'REGISTRY_CHECK_DONE': {
-            const { isUpdate, resolvedVersion, token, versionCheck } = action;
-            let nextPhase;
-            let errorMessage = state.errorMessage;
-            let bumpedVersion = resolvedVersion;
-            let bumpedTarget = state.target;
-            if (versionCheck.status === 'new-asset') {
-                nextPhase = 'building-plan';
-            }
-            else if (versionCheck.status === 'version-already-bumped') {
-                // --yes / non-TTY implicitly confirm the update
-                nextPhase = state.nonInteractive ? 'building-plan' : 'confirm-update';
-            }
-            else {
-                // needs-bump
-                if (state.nonInteractive) {
-                    if (state.flags.bump && state.target) {
-                        // Auto-bump using the flag value; a successful publish writes it to the manifest
-                        try {
-                            bumpedVersion = bumpVersion(versionCheck.latestVersion, state.flags.bump);
-                            bumpedTarget = {
-                                ...state.target,
-                                data: { ...state.target.data, version: bumpedVersion },
-                            };
-                            nextPhase = 'building-plan';
-                        }
-                        catch {
-                            errorMessage = 'Failed to compute bumped version.';
-                            nextPhase = 'error';
-                        }
-                    }
-                    else if (isBatch(state.flags)) {
-                        // advanceToPlan lists every asset of the batch that needs --bump, once the entries are checked.
-                        nextPhase = 'building-plan';
-                    }
-                    else {
-                        errorMessage = `--bump <patch|minor|major> required: registry has v${versionCheck.latestVersion} but manifest is not newer`;
-                        nextPhase = 'error';
-                    }
-                }
-                else {
-                    nextPhase = 'bump-prompt';
-                }
-            }
-            const checked = {
-                ...state,
-                errorMessage,
-                isUpdate,
-                phase: nextPhase,
-                resolvedVersion: bumpedVersion,
-                target: bumpedTarget,
-                token,
-                versionCheck,
-            };
-            return nextPhase === 'building-plan' ? advanceToPlan(checked) : checked;
-        }
-        case 'RESOLVE_TOOLS_NONINTERACTIVE': {
-            const updatedTarget = state.target
-                ? {
-                    ...state.target,
-                    data: { ...state.target.data, tools: action.tools },
-                }
-                : undefined;
-            return {
-                ...state,
-                phase: 'checking-registry',
-                target: updatedTarget,
-            };
-        }
-        case 'RESOLVED_INSTALLED':
-            return {
-                ...state,
-                phase: 'detecting',
-                resolvedPath: action.resolvedPath,
-            };
-        case 'RESOLVED_UPDATE':
-            return {
-                ...state,
-                phase: 'detecting',
-                resolvedPath: action.resolvedPath,
-            };
-        case 'SET_BUMP_SELECTION':
-            return { ...state, bumpSelection: action.value };
-        case 'SET_CONFIRM_VALUE':
-            return { ...state, confirmValue: action.value };
-        case 'SET_DESCRIPTION':
-            return { ...state, descriptionValue: action.value };
-        case 'SET_PROMPT_TAGS':
-            return { ...state, promptTagsValue: action.value };
-        case 'SET_PUBLISH_CONFIRM_VALUE':
-            return { ...state, publishConfirmValue: action.value };
-        case 'SET_REVIEWER':
-            return { ...state, reviewerValue: action.value };
-        case 'SET_TAGS':
-            return { ...state, tagsValue: action.value };
-        case 'SET_WITH_CONFIRM_VALUE':
-            return { ...state, withConfirmValue: action.value };
-        case 'STAGING_DONE':
-            return {
-                ...state,
-                phase: 'validating',
-                target: action.target,
-            };
-        case 'SUBMIT_BUMP': {
-            const trimmed = state.bumpSelection.trim().toLowerCase();
-            if (trimmed !== 'patch' && trimmed !== 'minor' && trimmed !== 'major') {
-                return state; // Ignore invalid input
-            }
-            // The prompt is for an entry: bump it, then on to the next pending bump or the plan.
-            if (state.bumpEntry !== undefined) {
-                const entry = state.entries[state.bumpEntry];
-                if (entry?.versionCheck?.status !== 'needs-bump')
-                    return state;
-                return bumpEntryAt({ ...state, bumpSelection: '' }, state.bumpEntry, trimmed);
-            }
-            if (!state.target || !state.versionCheck || state.versionCheck.status !== 'needs-bump') {
-                return state;
-            }
-            // Compute the bumped version in the reducer (pure, synchronous)
-            const bumpType = trimmed;
-            try {
-                const newVersion = bumpVersion(state.versionCheck.latestVersion, bumpType);
-                // The bump is only on the target until the publish succeeds, which writes it to
-                // the manifest; entries still to check or bump come first.
-                return advanceToPlan({
-                    ...state,
-                    bumpSelection: '',
-                    resolvedVersion: newVersion,
-                    target: { ...state.target, data: { ...state.target.data, version: newVersion } },
-                });
-            }
-            catch {
-                return {
-                    ...state,
-                    errorMessage: 'Failed to compute bumped version.',
-                    phase: 'error',
-                };
-            }
-        }
-        case 'SUBMIT_CONFIRM': {
-            const trimmed = state.confirmValue.trim().toLowerCase();
-            if (trimmed === 'y' || trimmed === 'yes') {
-                return advanceToPlan(state);
-            }
-            else if (trimmed === 'n' || trimmed === 'no') {
-                return { ...state, errorMessage: 'Publish cancelled.', phase: 'error' };
-            }
-            // Otherwise ignore (wait for valid input)
-            return state;
-        }
-        case 'SUBMIT_DESCRIPTION': {
-            const trimmed = state.descriptionValue.trim();
-            if (!trimmed)
-                return state; // Don't allow empty description
-            return {
-                ...state,
-                descriptionValue: trimmed,
-                metadataSubPhase: 'tags',
-            };
-        }
-        case 'SUBMIT_PROMPT_TAGS': {
-            const parsedTags = splitList(state.promptTagsValue);
-            // Update the target's data with the new tags
-            const updatedTagsTarget = state.target
-                ? {
-                    ...state.target,
-                    data: { ...state.target.data, tags: parsedTags.length > 0 ? parsedTags : undefined },
-                }
-                : undefined;
-            // Check if tools are also missing (only for assets)
-            const needsToolsPrompt = updatedTagsTarget?.type === 'asset' &&
-                (!('tools' in updatedTagsTarget.data) ||
-                    !Array.isArray(updatedTagsTarget.data.tools) ||
-                    (updatedTagsTarget.data.tools?.length ?? 0) === 0);
-            const nextTagsPhase = needsToolsPrompt ? 'loading-tools' : phaseAfterMetadata(updatedTagsTarget);
-            return {
-                ...state,
-                phase: nextTagsPhase,
-                target: updatedTagsTarget,
-            };
-        }
-        case 'SUBMIT_PUBLISH_CONFIRM': {
-            const trimmed = state.publishConfirmValue.trim().toLowerCase();
-            if (trimmed === 'y' || trimmed === 'yes') {
-                return { ...state, phase: 'publishing' };
-            }
-            else if (trimmed === 'n' || trimmed === 'no') {
-                return { ...state, errorMessage: 'Publish cancelled.', phase: 'error' };
-            }
-            // Otherwise ignore (wait for valid input)
-            return state;
-        }
-        case 'SUBMIT_REVIEWER':
-            return { ...state, phase: 'checking-registry' };
-        case 'SUBMIT_TAGS':
-            return {
-                ...state,
-                metadataSubPhase: 'building-staging',
-            };
-        case 'SUBMIT_WITH_CONFIRM': {
-            const trimmed = state.withConfirmValue.trim().toLowerCase();
-            if (trimmed === 'y' || trimmed === 'yes') {
-                return advanceToPlan({
-                    ...state,
-                    entries: [...state.entries, ...state.suggestedEntries],
-                    missingDependencies: [],
-                    pendingError: undefined,
-                    suggestedEntries: [],
-                    withConfirmValue: '',
-                });
-            }
-            if ((trimmed === 'n' || trimmed === 'no') && state.pendingError) {
-                return publishReducer({ ...state, suggestedEntries: [], withConfirmValue: '' }, state.pendingError);
-            }
-            return state;
-        }
-        case 'SUGGEST_ENTRIES':
-            return {
-                ...state,
-                missingDependencies: action.missing,
-                pendingError: action.error,
-                phase: 'confirm-with',
-                suggestedEntries: action.suggested,
-                withConfirmValue: '',
-            };
         case 'TOGGLE_PROMPT_TOOL': {
-            const toolSet = new Set(state.selectedPromptTools);
+            const toolSet = new Set(picker.selected);
             if (toolSet.has(action.tool)) {
                 toolSet.delete(action.tool);
             }
             else {
                 toolSet.add(action.tool);
             }
-            return {
-                ...state,
-                selectedPromptTools: [...toolSet],
-            };
-        }
-        case 'TOOL_CURSOR_DOWN': {
-            if (state.toolAdapters.length === 0)
-                return state;
-            return {
-                ...state,
-                toolCursorIndex: state.toolCursorIndex >= state.toolAdapters.length - 1 ? 0 : state.toolCursorIndex + 1,
-            };
-        }
-        case 'TOOL_CURSOR_UP': {
-            if (state.toolAdapters.length === 0)
-                return state;
-            return {
-                ...state,
-                toolCursorIndex: state.toolCursorIndex <= 0 ? state.toolAdapters.length - 1 : state.toolCursorIndex - 1,
-            };
-        }
-        case 'TOOLS_LOADED':
-            return {
-                ...state,
-                phase: 'prompting-tools',
-                toolAdapters: action.adapters,
-                toolCursorIndex: 0,
-            };
-        case 'VALIDATE_DONE': {
-            if (!action.validation.valid) {
-                return {
-                    ...state,
-                    errorMessage: `Validation failed:\n${action.validation.errors.map((e) => `  - ${e}`).join('\n')}`,
-                    phase: 'error',
-                    validation: action.validation,
-                };
-            }
-            // Seed the reviewers field: the --reviewer flag wins over the project's
-            // lockfile-configured default (org.ts's CLI-flag > lockfile priority chain).
-            const reviewerValue = state.flags.reviewerFlag ?? (action.lockfileOrgReviewers ?? []).join(', ');
-            // Determine next phase based on missing tags/tools. A batch asks for neither: as for
-            // a --with entry, a missing one is only a warning.
-            const batch = isBatch(state.flags);
-            const manifest = state.target?.data;
-            const hasTags = batch || (manifest && 'tags' in manifest && Array.isArray(manifest.tags) && manifest.tags.length > 0);
-            const hasTools = batch ||
-                // Only assets have tools; bundles skip the tools prompt
-                state.target?.type !== 'asset' ||
-                (manifest && 'tools' in manifest && Array.isArray(manifest.tools) && manifest.tools.length > 0);
-            const isOrgScoped = batch
-                ? [state.target, ...state.entries.map((entry) => entry.target)].some((t) => t && isOrgScopedTarget(t))
-                : Boolean(state.target && isOrgScopedTarget(state.target));
-            // Reviewers only apply to org-scoped assets (non-org PRs always go to the registry
-            // maintainer) — fail fast rather than silently ignoring the flag.
-            if (!isOrgScoped && state.flags.reviewerFlag && parseReviewersInput(state.flags.reviewerFlag).length > 0) {
-                return {
-                    ...state,
-                    errorMessage: 'The --reviewer flag only applies to org-scoped assets. Remove the flag to publish this asset.',
-                    phase: 'error',
-                    validation: action.validation,
-                };
-            }
-            // Non-interactive path: resolve tags from --tags flag (or empty) right here, then
-            // either route to loading-tools (effect resolves tools async) or directly to
-            // checking-registry. Manifest tags always win when present. The reviewer prompt
-            // never applies here — non-interactive mode always skips it.
-            if (state.nonInteractive) {
-                let nextTarget = state.target;
-                if (!hasTags && nextTarget) {
-                    const flagTags = splitList(state.flags.tagsFlag);
-                    nextTarget = {
-                        ...nextTarget,
-                        data: { ...nextTarget.data, tags: flagTags.length > 0 ? flagTags : undefined },
-                    };
-                }
-                let nextPhase;
-                if (!hasTools) {
-                    // The loading-tools effect detects whether we're non-interactive and
-                    // either resolves tools from the manifest/flag/inference or errors out.
-                    nextPhase = 'loading-tools';
-                }
-                else {
-                    nextPhase = 'checking-registry';
-                }
-                return {
-                    ...state,
-                    phase: nextPhase,
-                    reviewerValue,
-                    target: nextTarget,
-                    validation: action.validation,
-                };
-            }
-            let nextPhase;
-            if (!hasTags) {
-                nextPhase = 'prompting-tags';
-            }
-            else if (!hasTools) {
-                nextPhase = 'loading-tools';
-            }
-            else {
-                nextPhase = isOrgScoped ? 'prompting-reviewer' : 'checking-registry';
-            }
-            return {
-                ...state,
-                phase: nextPhase,
-                reviewerValue,
-                validation: action.validation,
-            };
+            return { ...picker, selected: [...toolSet] };
         }
-        default:
-            return state;
+        case 'TOOL_CURSOR_DOWN':
+            if (action.count === 0)
+                return picker;
+            return { ...picker, cursor: picker.cursor >= action.count - 1 ? 0 : picker.cursor + 1 };
+        case 'TOOL_CURSOR_UP':
+            if (action.count === 0)
+                return picker;
+            return { ...picker, cursor: picker.cursor <= 0 ? action.count - 1 : picker.cursor - 1 };
     }
 }
 /**
- * The publish flow's state for the command's UI. The reducer moves it through its
- * phases; on each phase that waits on work, the step in `lib/publish-flow.ts` runs
- * and dispatches what it found.
+ * The publish flow for the command's UI. `runPublish` (lib/publish-run.ts) runs it once
+ * and this mirrors each state it moves to. The hook is its prompter: a prompt waits on
+ * `input`, which shows the state's own value for that prompt (an answer the reducer
+ * didn't take stays) until something is typed, or, for tools, on `picker`.
  */
 export function usePublishState(flags) {
-    const [state, dispatch] = useReducer(publishReducer, undefined, () => createInitialState(flags));
-    // Staging directories (--from-installed, --update, a raw publish's manifest) to remove at the end
-    const stagingDirs = useRef([]);
-    const unmounted = useRef(false);
-    const removeStagingDirs = (dirs) => {
-        for (const dir of dirs.splice(0)) {
-            rm(dir, { force: true, recursive: true }).catch(() => {
-                // Best-effort cleanup — ignore errors
-            });
-        }
-    };
-    // Phase-gated: the step runs once on entering its phase (or the building-staging sub-phase)
+    const [state, setState] = useState(() => createInitialState(flags));
+    // What was typed, and for which state: a new state shows its own value, in the same render
+    const [edit, setEdit] = useState();
+    const [picker, setPicker] = useState({ cursor: 0, selected: [] });
+    // Enter and the picker's keys read the latest input, as the reducer read its own fields, not a render's
+    const typed = useRef('');
+    const ticked = useRef(picker);
+    const answer = useRef(undefined);
+    const answerTools = useRef(undefined);
     useEffect(() => {
-        let cancelled = false;
-        void runPublishStep(state, {
-            cancelled: () => cancelled,
-            dispatch,
-            stage: (dir) => {
-                stagingDirs.current.push(dir);
-                // A step that outlived the command still leaves nothing behind
-                if (unmounted.current)
-                    removeStagingDirs(stagingDirs.current);
-            },
+        const ask = (s) => new Promise((resolve) => {
+            typed.current = promptValue(s);
+            answer.current = resolve;
         });
+        const prompter = {
+            bump: ask,
+            confirmPublish: ask,
+            confirmUpdate: ask,
+            confirmWith: ask,
+            description: ask,
+            rawTags: ask,
+            reviewers: ask,
+            tags: ask,
+            tools: () => new Promise((resolve) => {
+                answerTools.current = resolve;
+            }),
+        };
+        // Unmounting aborts the run: it drops the pending prompt and removes the staging directories
+        const controller = new AbortController();
+        void runPublish(flags, prompter, { onState: setState, signal: controller.signal });
         return () => {
-            cancelled = true;
+            controller.abort();
         };
         // eslint-disable-next-line react-hooks/exhaustive-deps
-    }, [state.phase, state.metadataSubPhase]);
-    // --- Cleanup temp directory on error or done ---
-    useEffect(() => {
-        if (state.phase !== 'error' && state.phase !== 'done' && state.phase !== 'dry-run-result')
-            return;
-        removeStagingDirs(stagingDirs.current);
-    }, [state.phase]);
-    // --- ...or when the command goes away before either ---
-    useEffect(() => () => {
-        unmounted.current = true;
-        removeStagingDirs(stagingDirs.current);
     }, []);
-    return [state, dispatch];
-}
-// ---------------------------------------------------------------------------
-// Pure reducer helpers
-// ---------------------------------------------------------------------------
-/**
- * The step before `building-plan`, once the root asset's own checks are done:
- * check the entries not yet checked, then settle each entry that needs a bump
- * (the bump prompt; `--bump` or an error when non-interactive), then plan.
- */
-function advanceToPlan(state) {
-    if (state.entries.some((entry) => !entry.versionCheck)) {
-        return { ...state, bumpEntry: undefined, phase: 'checking-entries' };
-    }
-    // A batch without --bump names every asset that needs one, not just the first.
-    if (isBatch(state.flags) && state.nonInteractive && !state.flags.bump) {
-        const pending = [
-            ...(state.target && state.versionCheck?.status === 'needs-bump' && !state.resolvedVersion
-                ? [{ label: state.flags.rawPath, latestVersion: state.versionCheck.latestVersion, target: state.target }]
-                : []),
-            ...state.entries.flatMap((entry) => entry.versionCheck?.status === 'needs-bump' && entry.resolvedVersion === undefined
-                ? [{ label: entry.label, latestVersion: entry.versionCheck.latestVersion, target: entry.target }]
-                : []),
-        ];
-        if (pending.length > 0) {
-            const lines = pending.map((p) => `  ${p.label}: ${p.target.assetType}:${p.target.data.name} v${p.target.data.version}, registry has v${p.latestVersion}`);
-            return {
-                ...state,
-                errorMessage: `--bump <patch|minor|major> required: these manifests are not newer than the registry:\n${lines.join('\n')}`,
-                phase: 'error',
-            };
-        }
-    }
-    const index = state.entries.findIndex((entry) => entry.versionCheck?.status === 'needs-bump' && entry.resolvedVersion === undefined);
-    const entry = state.entries[index];
-    if (entry?.versionCheck?.status !== 'needs-bump') {
-        return { ...state, bumpEntry: undefined, phase: 'building-plan' };
-    }
-    if (!state.nonInteractive) {
-        return { ...state, bumpEntry: index, bumpSelection: '', phase: 'bump-prompt' };
-    }
-    const { latestVersion } = entry.versionCheck;
-    if (!state.flags.bump) {
-        return {
-            ...state,
-            errorMessage: `--bump <patch|minor|major> required: registry has v${latestVersion} of ${entry.target.assetType}:${entry.target.data.name} (from ${entry.label}) but its manifest is not newer`,
-            phase: 'error',
-        };
-    }
-    return bumpEntryAt(state, index, state.flags.bump);
-}
-/**
- * Bump the entry at `index` from its registry version, then go on toward the
- * plan; an error state, as for the root, when the version can't be bumped.
- */
-function bumpEntryAt(state, index, bump) {
-    const entry = state.entries[index];
-    if (entry?.versionCheck?.status !== 'needs-bump')
-        return state;
-    let version;
-    try {
-        version = bumpVersion(entry.versionCheck.latestVersion, bump);
-    }
-    catch {
-        return { ...state, errorMessage: `Failed to compute bumped version for ${entry.label}.`, phase: 'error' };
-    }
-    return advanceToPlan({ ...state, entries: replaceEntry(state.entries, index, withVersion(entry, version)) });
-}
-/**
- * Phase to enter once the tags/tools metadata prompts are resolved: org-scoped
- * targets get the reviewer prompt, everything else proceeds to the registry check.
- */
-function phaseAfterMetadata(target) {
-    return target && isOrgScopedTarget(target) ? 'prompting-reviewer' : 'checking-registry';
-}
-function replaceEntry(entries, index, entry) {
-    return entries.map((current, i) => (i === index ? entry : current));
-}
-/** The entry published at `version`; a successful publish writes it to the entry's manifest. */
-function withVersion(entry, version) {
-    return {
-        ...entry,
-        resolvedVersion: version,
-        target: { ...entry.target, data: { ...entry.target.data, version } },
+    const input = {
+        onChange: (text) => {
+            typed.current = text;
+            setEdit({ for: state, text });
+        },
+        onSubmit: () => {
+            const resolve = answer.current;
+            answer.current = undefined;
+            resolve?.(typed.current);
+        },
+        value: edit?.for === state ? edit.text : promptValue(state),
+    };
+    const pick = (action) => {
+        ticked.current = toolPickerReducer(ticked.current, action);
+        setPicker(ticked.current);
+    };
+    const count = state.toolAdapters.length;
+    const toolPicker = {
+        ...picker,
+        confirm: () => {
+            if (ticked.current.selected.length === 0)
+                return;
+            const resolve = answerTools.current;
+            answerTools.current = undefined;
+            resolve?.(ticked.current.selected);
+        },
+        down: () => pick({ count, type: 'TOOL_CURSOR_DOWN' }),
+        toggle: () => {
+            const tool = state.toolAdapters[ticked.current.cursor]?.tool;
+            if (tool)
+                pick({ tool, type: 'TOGGLE_PROMPT_TOOL' });
+        },
+        up: () => pick({ count, type: 'TOOL_CURSOR_UP' }),
     };
+    return { input, picker: toolPicker, state };
 }
 //# sourceMappingURL=usePublishState.js.map