@zapier/zapier-sdk-cli 0.59.1 → 0.59.3

package/dist/src/utils/parameter-resolver.js

@@ -1,1554 +0,0 @@
-import inquirer from "inquirer";
-import search from "@inquirer/search";
-import chalk from "chalk";
-import ora from "ora";
-import { z } from "zod";
-import { runWithTelemetryContext, } from "@zapier/zapier-sdk";
-import { isPositional, buildCapabilityMessage } from "@zapier/zapier-sdk";
-import { ZapierCliUserCancellationError, ZapierCliMissingParametersError, ZapierCliValidationError, } from "./errors";
-// Zod validation errors are structured objects; flatten them into a
-// readable "field: reason" string for CLI error messages.
-function formatZodError(error) {
-    return error.issues
-        .map((issue) => {
-        const field = issue.path.length > 0 ? issue.path.join(".") : "input";
-        return `${field}: ${issue.message}`;
-    })
-        .join(", ");
-}
-// ============================================================================
-// Local Resolution Helper Functions
-// ============================================================================
-/**
- * Resolve dependency chain for a parameter using local resolvers
- * Returns parameters in the order they need to be resolved
- */
-function getLocalResolutionOrder(paramName, resolvers, resolved = new Set()) {
-    const resolver = resolvers[paramName];
-    if (!resolver || resolver.type === "static" || resolver.type === "constant") {
-        return [paramName];
-    }
-    const order = [];
-    if ("depends" in resolver && resolver.depends) {
-        for (const dependency of resolver.depends) {
-            if (!resolved.has(dependency)) {
-                order.push(...getLocalResolutionOrder(dependency, resolvers, resolved));
-                resolved.add(dependency);
-            }
-        }
-    }
-    if (!resolved.has(paramName)) {
-        order.push(paramName);
-        resolved.add(paramName);
-    }
-    return order;
-}
-/**
- * Get resolution order for multiple parameters using local resolvers
- */
-function getLocalResolutionOrderForParams(paramNames, resolvers) {
-    const resolved = new Set();
-    const order = [];
-    for (const paramName of paramNames) {
-        const paramOrder = getLocalResolutionOrder(paramName, resolvers, resolved);
-        for (const param of paramOrder) {
-            if (!order.includes(param)) {
-                order.push(param);
-            }
-        }
-    }
-    return order;
-}
-function unwrapSchema(schema) {
-    let current = schema;
-    while (current instanceof z.ZodOptional ||
-        current instanceof z.ZodDefault ||
-        current instanceof z.ZodNullable) {
-        current = current._zod.def.innerType;
-    }
-    return current;
-}
-function coerceToSchemaType(value, schema) {
-    if (typeof value !== "string")
-        return value;
-    const base = unwrapSchema(schema);
-    if (base instanceof z.ZodNumber) {
-        const n = Number(value);
-        return Number.isNaN(n) ? value : n;
-    }
-    if (base instanceof z.ZodBoolean) {
-        if (value === "true")
-            return true;
-        if (value === "false")
-            return false;
-    }
-    return value;
-}
-// ============================================================================
-// Schema Parameter Resolver
-// ============================================================================
-/**
- * Append a choice's `hint` to its name as dimmed parens, returning a new
- * choice object. An array hint is joined with ", ". Used by every prompt
- * backend that renders resolver-supplied choices so the dim styling lives
- * in one place.
- *
- * Default-when-unset: if `hint` is not provided and the choice's `value`
- * is a primitive (string or number), the value is auto-rendered as the
- * hint. So a resolver returning `{ name: "Slack", value: "SlackCLIAPI" }`
- * with no `hint` renders as `Slack (SlackCLIAPI)`. To opt out of the
- * auto-default, set `hint: ""` or `hint: []` explicitly.
- *
- * Skip-when-equal: a hint that matches the rendered name verbatim is
- * suppressed so primitive-enum resolvers (where `name === String(value)`)
- * don't render "read (read)". Case differences still render both.
- */
-export function renderChoiceLabel(choice) {
-    let effectiveHint = choice.hint;
-    if (effectiveHint === undefined &&
-        (typeof choice.value === "string" || typeof choice.value === "number")) {
-        effectiveHint = String(choice.value);
-    }
-    if (!effectiveHint ||
-        (Array.isArray(effectiveHint) && effectiveHint.length === 0)) {
-        return choice;
-    }
-    const hintText = Array.isArray(effectiveHint)
-        ? effectiveHint.join(", ")
-        : effectiveHint;
-    if (hintText === choice.name) {
-        return choice;
-    }
-    return { ...choice, name: `${choice.name} ${chalk.dim(`(${hintText})`)}` };
-}
-export class SchemaParameterResolver {
-    constructor() {
-        this.debug = false;
-        this.spinner = null;
-    }
-    debugLog(message) {
-        if (this.debug) {
-            this.stopSpinner();
-            // stderr so debug output never pollutes stdout (jq, > redirect,
-            // JSON.parse all consume stdout).
-            console.error(chalk.gray(`[Zapier CLI] ${message}`));
-        }
-    }
-    startSpinner() {
-        if (!this.debug && !this.spinner) {
-            this.spinner = ora({ text: "", spinner: "dots" }).start();
-        }
-    }
-    stopSpinner() {
-        if (this.spinner) {
-            this.spinner.stop();
-            this.spinner = null;
-        }
-    }
-    async resolveParameters(schema, providedParams, sdk, functionName, options) {
-        return runWithTelemetryContext(async () => {
-            this.debug = options?.debug ?? false;
-            const interactiveMode = (options?.interactiveMode ?? true) && !!process.stdin.isTTY;
-            // 1. Try to parse with current parameters
-            const parseResult = schema.safeParse(providedParams);
-            // Get all schema parameters to check which ones have resolvers
-            const allParams = this.extractParametersFromSchema(schema);
-            const resolvableParams = allParams.filter((param) => this.hasResolver(param.name, sdk, functionName));
-            // Get all missing parameters that have resolvers
-            const missingResolvable = resolvableParams.filter((param) => {
-                const hasValue = this.getNestedValue(providedParams, param.path) !== undefined;
-                return !hasValue;
-            });
-            // Split missing resolvable params into required vs optional based on
-            // schema. Optional params still get prompted in interactive mode, but
-            // in a second pass after the schema-required ones (and their resolver
-            // dependencies) are settled.
-            const required = missingResolvable.filter((param) => param.isRequired);
-            const optional = missingResolvable.filter((param) => !param.isRequired);
-            if (parseResult.success &&
-                required.length === 0 &&
-                optional.length === 0) {
-                return parseResult.data;
-            }
-            if (required.length === 0 && optional.length === 0) {
-                if (!parseResult.success) {
-                    throw new ZapierCliValidationError(formatZodError(parseResult.error));
-                }
-                return parseResult.data;
-            }
-            // 2. Resolve required parameters
-            // Seed resolvedParams with constant resolvers — entries in `resolvers`
-            // typed `{ type: "constant", value }` for parameters not in the schema.
-            // Used when a dependent resolver needs a value the user never sets
-            // (e.g., trigger plugins pin actionType="read" so actionKeyResolver
-            // and inputsResolver work without actionType being a real input).
-            const resolverConstants = this.getResolverConstants(sdk, functionName);
-            const resolvedParams = {
-                ...resolverConstants,
-                ...providedParams,
-            };
-            const context = {
-                sdk,
-                currentParams: providedParams,
-                resolvedParams,
-                functionName,
-            };
-            const localResolvers = this.getLocalResolvers(sdk, functionName);
-            if (required.length > 0) {
-                const requiredParamNames = required.map((p) => p.name);
-                const requiredResolutionOrder = getLocalResolutionOrderForParams(requiredParamNames, localResolvers);
-                // Find all parameters that need to be resolved (including dependencies)
-                const orderedRequiredParams = requiredResolutionOrder
-                    .map((paramName) => {
-                    let param = required.find((p) => p.name === paramName);
-                    if (!param) {
-                        param = optional.find((p) => p.name === paramName);
-                    }
-                    return param;
-                })
-                    .filter((param) => param !== undefined);
-                if (!interactiveMode) {
-                    await this.resolveRequiredParamsNonInteractive(orderedRequiredParams, context, resolvedParams, functionName);
-                }
-                else {
-                    for (const param of orderedRequiredParams) {
-                        try {
-                            const value = await this.resolveParameter(param, context, functionName, { isOptional: !param.isRequired });
-                            if (param.isRequired || value !== undefined) {
-                                this.setNestedValue(resolvedParams, param.path, value);
-                                context.resolvedParams = resolvedParams;
-                            }
-                        }
-                        catch (error) {
-                            if (this.isUserCancellation(error)) {
-                                console.log(chalk.yellow("\n\nOperation cancelled by user"));
-                                throw new ZapierCliUserCancellationError();
-                            }
-                            throw error;
-                        }
-                    }
-                }
-                // Remove resolved dependencies from optional to avoid double-prompting
-                const resolvedParamNames = new Set(orderedRequiredParams.map((p) => p.name));
-                optional.splice(0, optional.length, ...optional.filter((p) => !resolvedParamNames.has(p.name)));
-            }
-            // 3. Resolve optional parameters individually (each is skippable).
-            // Skipped in non-interactive mode.
-            if (interactiveMode && optional.length > 0) {
-                const optionalParamNames = optional.map((p) => p.name);
-                const optionalResolutionOrder = getLocalResolutionOrderForParams(optionalParamNames, localResolvers);
-                const orderedOptionalParams = optionalResolutionOrder
-                    .map((paramName) => optional.find((p) => p.name === paramName))
-                    .filter((param) => param !== undefined);
-                for (const param of orderedOptionalParams) {
-                    try {
-                        const value = await this.resolveParameter(param, context, functionName, { isOptional: true });
-                        if (value !== undefined) {
-                            this.setNestedValue(resolvedParams, param.path, value);
-                            context.resolvedParams = resolvedParams;
-                        }
-                    }
-                    catch (error) {
-                        if (this.isUserCancellation(error)) {
-                            console.log(chalk.yellow("\n\nOperation cancelled by user"));
-                            throw new ZapierCliUserCancellationError();
-                        }
-                        throw error;
-                    }
-                }
-            }
-            // 4. Validate final parameters
-            const finalResult = schema.safeParse(resolvedParams);
-            if (!finalResult.success) {
-                throw new ZapierCliValidationError(`Parameter validation failed: ${formatZodError(finalResult.error)}`);
-            }
-            return finalResult.data;
-        });
-    }
-    extractParametersFromSchema(schema) {
-        const parameters = [];
-        // Only handle ZodObject at the top level
-        if (schema instanceof z.ZodObject) {
-            const shape = schema.shape;
-            for (const [key, fieldSchema] of Object.entries(shape)) {
-                const param = this.analyzeFieldSchema(key, fieldSchema);
-                if (param) {
-                    parameters.push(param);
-                }
-            }
-        }
-        return parameters;
-    }
-    analyzeFieldSchema(fieldName, fieldSchema) {
-        let baseSchema = fieldSchema;
-        let isRequired = true;
-        // Check if field is optional or has default
-        if (baseSchema instanceof z.ZodOptional) {
-            isRequired = false;
-            baseSchema = baseSchema._zod.def.innerType;
-        }
-        if (baseSchema instanceof z.ZodDefault) {
-            isRequired = false;
-            baseSchema = baseSchema._zod.def.innerType;
-        }
-        return this.createResolvableParameter([fieldName], baseSchema, isRequired);
-    }
-    createResolvableParameter(path, schema, isRequired) {
-        if (path.length === 0)
-            return null;
-        const name = path[path.length - 1];
-        return {
-            name,
-            path,
-            schema,
-            description: schema.description,
-            isRequired,
-        };
-    }
-    /**
-     * Calls `tryResolveWithoutPrompt` on a dynamic resolver.
-     * Returns the resolution result object, or null if unresolvable / throws.
-     * Note: { resolvedValue: undefined } is a valid result (e.g. connection when app has no auth);
-     * only a null return from the resolver itself means "could not auto-resolve".
-     */
-    async tryAutoResolve(dynamicResolver, context) {
-        if (!dynamicResolver.tryResolveWithoutPrompt)
-            return null;
-        try {
-            return await dynamicResolver.tryResolveWithoutPrompt(context.sdk, context.resolvedParams);
-        }
-        catch (err) {
-            console.warn(`Auto-resolver threw unexpectedly; treating as unresolved. Error: ${err instanceof Error ? err.message : String(err)}`);
-            return null;
-        }
-    }
-    /**
-     * Non-interactive resolution: auto-resolves what it can via tryAutoResolve,
-     * throws ZapierCliMissingParametersError for anything that requires user input.
-     */
-    async resolveRequiredParamsNonInteractive(params, context, resolvedParams, functionName) {
-        const missingParams = [];
-        for (const param of params) {
-            const resolver = this.getResolver(param.name, context.sdk, functionName);
-            let autoResolved = null;
-            if (resolver?.type === "constant") {
-                autoResolved = {
-                    resolvedValue: resolver.value,
-                };
-            }
-            else if (resolver?.type === "dynamic") {
-                autoResolved = await this.tryAutoResolve(resolver, context);
-            }
-            if (autoResolved != null) {
-                this.setNestedValue(resolvedParams, param.path, autoResolved.resolvedValue);
-                context.resolvedParams = resolvedParams;
-            }
-            else {
-                missingParams.push({
-                    name: param.name,
-                    // Required params render as positional CLI args (<name>); so do explicitly positional optional params.
-                    isPositional: param.isRequired || isPositional(param.schema),
-                });
-            }
-        }
-        if (missingParams.length > 0) {
-            throw new ZapierCliMissingParametersError(missingParams);
-        }
-    }
-    /**
-     * Wrap a PromptConfig.validate so internal sentinels (Symbols) bypass
-     * it. The resolver's validator is intended for actual user values; our
-     * Skip / Custom / Load-more sentinels are internal control-flow and
-     * should pass through. Returns `undefined` when the resolver didn't
-     * supply a validator (so `await search({ ...rest })` doesn't get a
-     * pass-through identity function).
-     */
-    wrapPromptValidate(validate) {
-        if (!validate)
-            return undefined;
-        return (value) => (typeof value === "symbol" ? true : validate(value));
-    }
-    /**
-     * Apply a PromptConfig.filter to a selected value, but only when the
-     * value is a real data choice (not an internal sentinel). @inquirer/search
-     * has no built-in filter hook, so the search-backed paths call this
-     * explicitly before returning.
-     */
-    applyPromptFilter(filter, value) {
-        if (!filter || typeof value === "symbol")
-            return value;
-        return filter(value);
-    }
-    /**
-     * If the resolver's PromptConfig sets a `default` value, move the
-     * matching choice to the front so it's the first selectable item in
-     * the rendered source. @inquirer/search has no built-in `default`
-     * option; first-selectable is what Enter picks, so reordering achieves
-     * the same semantics inquirer.prompt's list had natively.
-     *
-     * Returns the original array if no default is set or the default
-     * doesn't match any current choice.
-     */
-    reorderForDefault(matches, defaultValue) {
-        if (defaultValue === undefined)
-            return matches;
-        const idx = matches.findIndex((c) => c.value === defaultValue);
-        if (idx <= 0)
-            return matches;
-        return [matches[idx], ...matches.slice(0, idx), ...matches.slice(idx + 1)];
-    }
-    /**
-     * Build the disabled "if you had X capability, more results would show"
-     * hints for any unmet capabilities the resolver declared. Returns the
-     * raw hint strings — callers wrap them into choice objects with whatever
-     * sentinel value they prefer (disabled choices' values are inert).
-     */
-    async computeCapabilityHints(resolver, context) {
-        if (!resolver.requireCapabilities)
-            return [];
-        const capContext = context.sdk.context;
-        if (!capContext.hasCapability)
-            return [];
-        const messages = [];
-        for (const cap of resolver.requireCapabilities) {
-            const enabled = await capContext.hasCapability(cap);
-            if (!enabled)
-                messages.push(buildCapabilityMessage(cap));
-        }
-        return messages;
-    }
-    /**
-     * Unpack a DynamicResolver.fetch result into the three shapes the caller
-     * cares about: a flat items array, an optional AsyncIterator for further
-     * pagination, and a hasMore flag. Centralizing keeps the AsyncIterable /
-     * `{data, nextCursor}` / `TItem[]` discrimination in one place — both
-     * the main dropdown loop and the search-mode flow consume it.
-     *
-     * The function is `async` for the AsyncIterable branch only (we eagerly
-     * consume the first page so callers don't have to discriminate). The
-     * other two branches return synchronously; an explicit Promise.resolve
-     * is unnecessary because async automatically wraps.
-     *
-     * Note: callers in search mode intentionally drop `pageIterator` /
-     * `hasMore` because each search() invocation re-prompts from scratch;
-     * pagination only matters when the prompt is the dropdown itself.
-     */
-    async unpackFetchResult(fetchResult, promptLabel) {
-        if (fetchResult != null &&
-            typeof fetchResult === "object" &&
-            Symbol.asyncIterator in fetchResult) {
-            const pageIterator = fetchResult[Symbol.asyncIterator]();
-            const first = await pageIterator.next();
-            if (!first.done && first.value) {
-                return {
-                    items: Array.isArray(first.value.data) ? first.value.data : [],
-                    pageIterator,
-                    hasMore: first.value.nextCursor != null,
-                };
-            }
-            return { items: [], pageIterator, hasMore: false };
-        }
-        if (fetchResult != null &&
-            typeof fetchResult === "object" &&
-            "data" in fetchResult) {
-            const page = fetchResult;
-            const hasMore = page.nextCursor != null;
-            if (hasMore) {
-                this.debugLog(`Resolver for ${promptLabel} has more pages but no iterator. ` +
-                    `Use toIterable() to enable "Load more..." support.`);
-            }
-            return {
-                items: Array.isArray(page.data) ? page.data : [],
-                pageIterator: null,
-                hasMore,
-            };
-        }
-        // Anything else (including null/undefined) is treated as an empty
-        // list — the cast on a plain array kept downstream code happy, but
-        // an `Array.isArray` guard is the honest version.
-        return {
-            items: Array.isArray(fetchResult) ? fetchResult : [],
-            pageIterator: null,
-            hasMore: false,
-        };
-    }
-    /**
-     * Search-mode dynamic resolver: prompts the user for free-form text, passes
-     * it to fetch via `search`, and either short-circuits on a primitive return
-     * (exact match) or renders the results as a search-filterable dropdown.
-     * Empty results still render the dropdown so the user can fall through to
-     * "(Use 'foo' as-is)" or "(Try a different search)" rather than being
-     * stuck.
-     *
-     * Known limitation: pagination beyond the first page is dropped. Each
-     * search() invocation re-prompts from scratch and the user is expected
-     * to refine their query if too many results came back. If a future
-     * high-cardinality search resolver needs Load-more here, the
-     * `pageIterator` / `hasMore` from `unpackFetchResult` is what to wire in.
-     */
-    async resolveDynamicWithSearchInput({ resolver, context, promptLabel, isOptional, }) {
-        // Suffix the placeholder onto the message rather than passing it as
-        // inquirer's `default`. `inquirer`'s `input` prompt renders `default`
-        // as prefilled text the user has to delete before typing — so a user
-        // who just starts typing ends up sending `${placeholder}${typed}` as
-        // the search term. As a message suffix the hint is read-only.
-        // Fold "(optional)" and the placeholder hint into one parenthetical
-        // so an optional search prompt with a hint reads
-        // "Enter or search app (optional, e.g., 'slack'):" rather than the
-        // double-paren "Enter or search app (optional) (e.g., 'slack'):".
-        const parenParts = [];
-        if (isOptional)
-            parenParts.push("optional");
-        if (resolver.placeholder)
-            parenParts.push(resolver.placeholder);
-        const parens = parenParts.length > 0 ? ` (${parenParts.join(", ")})` : "";
-        const message = `Enter or search ${promptLabel}${parens}:`;
-        // Sentinels are loop-invariant — hoist so they aren't reallocated on
-        // every re-prompt. Identity comparisons against `selected` still work
-        // because the same Symbol references are reused.
-        const SKIP_SENTINEL = Symbol("SKIP");
-        const USE_AS_IS_SENTINEL = Symbol("USE_AS_IS");
-        const TRY_AGAIN_SENTINEL = Symbol("TRY_AGAIN");
-        let lastNote;
-        while (true) {
-            this.stopSpinner();
-            if (lastNote) {
-                console.log(chalk.yellow(lastNote));
-                lastNote = undefined;
-            }
-            const answers = await inquirer.prompt([
-                { type: "input", name: "search", message },
-            ]);
-            const rawInput = answers.search;
-            const searchInput = typeof rawInput === "string" ? rawInput.trim() : "";
-            if (!searchInput) {
-                if (isOptional)
-                    return undefined;
-                lastNote = `${promptLabel} is required.`;
-                continue;
-            }
-            // Build params once with `search` injected; pass to both fetch and
-            // prompt. The public type tells search-mode resolver authors to
-            // model TParams as `{ search?: string; ...otherDeps }`, so their
-            // prompt() can rely on seeing the term too.
-            const searchParams = {
-                ...context.resolvedParams,
-                search: searchInput,
-            };
-            this.startSpinner();
-            this.debugLog(`Searching ${promptLabel} for "${searchInput}"`);
-            let fetchResult;
-            try {
-                fetchResult = await resolver.fetch(context.sdk, searchParams);
-            }
-            finally {
-                this.stopSpinner();
-            }
-            if (typeof fetchResult === "string" || typeof fetchResult === "number") {
-                return fetchResult;
-            }
-            const { items } = await this.unpackFetchResult(fetchResult, promptLabel);
-            const choicesConfig = resolver.prompt(items, searchParams);
-            const dataChoices = (choicesConfig.choices ?? []).map(renderChoiceLabel);
-            const capabilityHintMessages = await this.computeCapabilityHints(resolver, context);
-            const selected = await search({
-                message: choicesConfig.message,
-                validate: this.wrapPromptValidate(choicesConfig.validate),
-                // @inquirer/search passes an AbortSignal as the second arg for
-                // cancelling async sources. All three of our source callbacks are
-                // pure-local (filter an already-fetched array), so we intentionally
-                // ignore the signal. A future server-side filter implementation
-                // would need to honor it.
-                source: (term) => {
-                    const trimmed = (term ?? "").trim();
-                    const lower = trimmed.toLowerCase();
-                    const matches = trimmed
-                        ? dataChoices.filter((c) => c.name.toLowerCase().includes(lower))
-                        : dataChoices;
-                    // @inquirer/search activates the first selectable item, so
-                    // matches always go first — the user already typed a query at
-                    // the text prompt to get here, and pressing Enter immediately
-                    // should pick the top match rather than (Skip) or one of the
-                    // escape hatches. If the resolver's PromptConfig sets a
-                    // default, surface that match as the first selectable.
-                    const orderedMatches = trimmed
-                        ? matches
-                        : this.reorderForDefault(matches, choicesConfig.default);
-                    const skipChoice = isOptional
-                        ? [{ name: chalk.dim("(Skip)"), value: SKIP_SENTINEL }]
-                        : [];
-                    // JSON.stringify handles the quoting + escape so an input like
-                    // `foo"bar` renders as `(Use "foo\"bar" as-is)` instead of
-                    // breaking the visible label with a stray quote.
-                    const useAsIsChoice = {
-                        name: chalk.dim(`(Use ${JSON.stringify(searchInput)} as-is)`),
-                        value: USE_AS_IS_SENTINEL,
-                    };
-                    const tryAgainChoice = {
-                        name: chalk.dim("(Try a different search)"),
-                        value: TRY_AGAIN_SENTINEL,
-                    };
-                    const out = [];
-                    if (orderedMatches.length === 0) {
-                        // Empty results: the user just typed something and got
-                        // nothing back. Pushing (Skip) first would make pressing
-                        // Enter surprise-skip the parameter they committed to. Bias
-                        // toward "use what I typed" and "try a different search."
-                        out.push(useAsIsChoice);
-                        out.push(tryAgainChoice);
-                        out.push(...skipChoice);
-                    }
-                    else {
-                        out.push(...orderedMatches);
-                        out.push(...skipChoice);
-                        out.push(useAsIsChoice);
-                        out.push(tryAgainChoice);
-                    }
-                    for (const message of capabilityHintMessages) {
-                        out.push({
-                            name: chalk.dim(message),
-                            value: SKIP_SENTINEL,
-                            disabled: true,
-                        });
-                    }
-                    return out;
-                },
-            });
-            if (selected === SKIP_SENTINEL)
-                return undefined;
-            // The (Use as-is) escape hatch is a real value heading into the
-            // same downstream slot as a picked match, so the resolver's
-            // validate and filter both apply. search()'s wrapped validate
-            // bypasses sentinels, so we have to invoke validate manually here
-            // with the typed string. On rejection, surface the validator's
-            // error as a yellow note above the next text prompt.
-            if (selected === USE_AS_IS_SENTINEL) {
-                const validationResult = choicesConfig.validate?.(searchInput);
-                if (validationResult === false) {
-                    lastNote = `${promptLabel}: invalid value.`;
-                    continue;
-                }
-                if (typeof validationResult === "string") {
-                    lastNote = validationResult;
-                    continue;
-                }
-                return this.applyPromptFilter(choicesConfig.filter, searchInput);
-            }
-            if (selected === TRY_AGAIN_SENTINEL)
-                continue;
-            return this.applyPromptFilter(choicesConfig.filter, selected);
-        }
-    }
-    async resolveParameter(param, context, functionName, options) {
-        const resolver = this.getResolver(param.name, context.sdk, functionName);
-        if (!resolver) {
-            throw new Error(`No resolver found for parameter: ${param.name}`);
-        }
-        return this.resolveWithResolver(resolver, param, context, {
-            isOptional: options?.isOptional,
-        });
-    }
-    /**
-     * Run a resolver to obtain a value for one parameter, prompting the
-     * user when necessary. Routes to one of several prompt backends and
-     * has to keep the `PromptConfig` contract honest across each one.
-     *
-     * `PromptConfig` field × prompt-backend handling:
-     *
-     *  | field    | list (search()) | checkbox/confirm (inquirer.prompt) | search-mode dropdown (search()) |
-     *  | -------- | --------------- | ---------------------------------- | ------------------------------- |
-     *  | type     | required        | required                           | required                        |
-     *  | name     | (set internally)| forwarded                          | (set internally)                |
-     *  | message  | forwarded       | forwarded                          | forwarded                       |
-     *  | choices  | filtered in src | passed to inquirer                 | filtered in src                 |
-     *  | default  | reorder matches | passed (also internal cursor jump) | reorder matches                 |
-     *  | validate | wrapped         | passed (inquirer native)           | wrapped + manual for (Use as-is)|
-     *  | filter   | manual once     | inquirer native (do NOT double)    | manual once                     |
-     *
-     * Escape-hatch sentinels (Skip / Custom value / Use as-is / Load more
-     * / Try again) bypass the resolver's validate/filter because they
-     * aren't real user values — they're CLI control-flow.
-     */
-    async resolveWithResolver(resolver, param, context, options = {}) {
-        const { arrayIndex, isOptional } = options;
-        const inArrayContext = arrayIndex != null;
-        const promptLabel = inArrayContext
-            ? `${param.name}[${arrayIndex}]`
-            : param.name;
-        const promptName = inArrayContext ? "value" : param.name;
-        this.debugLog(`Resolving ${promptLabel}${isOptional ? " (optional)" : ""}`);
-        if (resolver.type === "constant") {
-            const constantResolver = resolver;
-            this.stopSpinner();
-            return constantResolver.value;
-        }
-        else if (resolver.type === "static") {
-            const staticResolver = resolver;
-            const promptConfig = {
-                type: staticResolver.inputType === "password" ? "password" : "input",
-                name: promptName,
-                message: `Enter ${promptLabel}${isOptional ? " (optional)" : ""}:`,
-                ...(staticResolver.placeholder && {
-                    default: staticResolver.placeholder,
-                }),
-            };
-            this.stopSpinner();
-            const answers = await inquirer.prompt([promptConfig]);
-            const value = answers[promptName];
-            if (isOptional &&
-                (value === undefined ||
-                    value === "" ||
-                    value === staticResolver.placeholder)) {
-                return undefined;
-            }
-            // Inquirer's "input" prompt always returns a string. Coerce to match
-            // the schema's underlying type so z.number()/z.boolean() validation
-            // doesn't reject the value.
-            return coerceToSchemaType(value, param.schema);
-        }
-        else if (resolver.type === "dynamic") {
-            const dynamicResolver = resolver;
-            this.startSpinner();
-            const autoResolution = await this.tryAutoResolve(dynamicResolver, context);
-            if (autoResolution != null) {
-                this.stopSpinner();
-                return autoResolution.resolvedValue;
-            }
-            if (dynamicResolver.inputType === "search") {
-                this.stopSpinner();
-                return await this.resolveDynamicWithSearchInput({
-                    resolver: dynamicResolver,
-                    context,
-                    promptLabel,
-                    isOptional: isOptional ?? false,
-                });
-            }
-            this.debugLog(`Fetching options for ${promptLabel}`);
-            let fetchResult;
-            try {
-                fetchResult = await dynamicResolver.fetch(context.sdk, context.resolvedParams);
-            }
-            finally {
-                // Mirror the search-mode pattern: stop the spinner whether fetch
-                // succeeds or throws, so a network/auth error doesn't leave the
-                // spinner spinning through the error bubbling.
-                this.stopSpinner();
-            }
-            // Primitive returns are only meaningful in `inputType: "search"`
-            // mode, where they signal an exact-match short-circuit. Without
-            // search mode there's nothing for the user to disambiguate, so a
-            // primitive here is a resolver bug. Warn the author loudly, then fall
-            // back to a manual text prompt so the user isn't stranded mid-command.
-            if (typeof fetchResult === "string" || typeof fetchResult === "number") {
-                console.error(chalk.yellow(`Resolver for ${promptLabel} returned a primitive value but is not in search mode. Set inputType: "search" on the resolver if you want exact-match short-circuit. Falling back to manual entry.`));
-                const fallbackAnswers = await inquirer.prompt([
-                    {
-                        type: "input",
-                        name: promptName,
-                        message: `Enter ${promptLabel}${isOptional ? " (optional)" : ""}:`,
-                    },
-                ]);
-                const fallbackValue = fallbackAnswers[promptName];
-                if (isOptional &&
-                    (fallbackValue === undefined || fallbackValue === "")) {
-                    return undefined;
-                }
-                return fallbackValue;
-            }
-            const unpacked = await this.unpackFetchResult(fetchResult, promptLabel);
-            let pageIterator = unpacked.pageIterator;
-            let items = unpacked.items;
-            let hasMore = unpacked.hasMore;
-            const LOAD_MORE_SENTINEL = Symbol("LOAD_MORE");
-            const SKIP_SENTINEL = Symbol("SKIP");
-            const CUSTOM_VALUE_SENTINEL = Symbol("CUSTOM_VALUE");
-            let newItemsStartIndex = -1;
-            while (true) {
-                const promptConfig = dynamicResolver.prompt(items, context.resolvedParams);
-                promptConfig.name = promptName;
-                // Fold any per-choice `hint` into the rendered name once, here, so
-                // both the search-backed list path and the checkbox path below
-                // pick up the dim styling without each having to know about hints.
-                if (promptConfig.choices) {
-                    promptConfig.choices = promptConfig.choices.map(renderChoiceLabel);
-                }
-                // Friendlier than inquirer's default "No selectable choices. All
-                // choices are disabled." when the resolver returns no items (or
-                // filters everything out in `prompt`). Use ZapierCliValidationError
-                // so the message renders to the user; ZapierCliExitError exits
-                // silently and would be confusing here.
-                const hasSelectableChoice = promptConfig.choices?.some((c) => !c.disabled);
-                if (!hasSelectableChoice && !hasMore) {
-                    throw new ZapierCliValidationError(`No ${promptLabel} available to select.`);
-                }
-                // Capability hints: shown when no more pages remain and the
-                // resolver advertised capabilities that would expand results.
-                // The Skip / (Enter custom value) / (Load more...) sentinels live
-                // in the list/checkbox branches below since the search-backed list
-                // path injects them via the source callback rather than mutating
-                // promptConfig.choices.
-                const capabilityHints = [];
-                if (!hasMore) {
-                    const hintMessages = await this.computeCapabilityHints(dynamicResolver, context);
-                    for (const message of hintMessages) {
-                        capabilityHints.push({
-                            name: chalk.dim(message),
-                            value: SKIP_SENTINEL,
-                            disabled: true,
-                        });
-                    }
-                }
-                let selected;
-                if (promptConfig.type === "list") {
-                    // Single-select dropdowns go through @inquirer/search so users
-                    // can type-to-filter long lists. (Load more...) sits as a trailer
-                    // and is reachable whether or not the search yielded matches; the
-                    // user retypes after loading because @inquirer/search can't seed
-                    // its input box.
-                    const dataChoices = promptConfig.choices ?? [];
-                    selected = await search({
-                        message: promptConfig.message,
-                        validate: this.wrapPromptValidate(promptConfig.validate),
-                        source: (term) => {
-                            const trimmed = (term ?? "").trim();
-                            const lower = trimmed.toLowerCase();
-                            const matches = trimmed
-                                ? dataChoices.filter((c) => c.name.toLowerCase().includes(lower))
-                                : dataChoices;
-                            const out = [];
-                            const skipChoice = isOptional
-                                ? [
-                                    {
-                                        name: chalk.dim("(Skip)"),
-                                        value: SKIP_SENTINEL,
-                                    },
-                                ]
-                                : [];
-                            const customValueChoice = {
-                                name: chalk.dim("(Enter custom value)"),
-                                value: CUSTOM_VALUE_SENTINEL,
-                            };
-                            // @inquirer/search activates the first selectable item.
-                            // Three cases, with one unifying rule: never put (Skip)
-                            // first when the user is committed (typed a filter,
-                            // default specified) — pressing Enter then surprise-skips.
-                            // - Has matches + (filtered or defaulted) → matches first,
-                            //   then Skip and Custom, then Load more as a trailer.
-                            // - No matches + filtered → Custom and Load more above
-                            //   Skip, so every constructive option beats out skipping.
-                            // - Otherwise (browsing) → Skip first (the conventional
-                            //   optional-dropdown UX), then Custom, matches, Load more.
-                            const orderedMatches = trimmed
-                                ? matches
-                                : this.reorderForDefault(matches, promptConfig.default);
-                            const matchesFirst = trimmed || promptConfig.default !== undefined;
-                            const loadMoreChoice = hasMore && pageIterator
-                                ? {
-                                    name: chalk.dim("(Load more...)"),
-                                    value: LOAD_MORE_SENTINEL,
-                                }
-                                : null;
-                            if (matchesFirst && orderedMatches.length > 0) {
-                                out.push(...orderedMatches);
-                                out.push(...skipChoice);
-                                out.push(customValueChoice);
-                                if (loadMoreChoice)
-                                    out.push(loadMoreChoice);
-                            }
-                            else if (matchesFirst) {
-                                out.push(customValueChoice);
-                                if (loadMoreChoice)
-                                    out.push(loadMoreChoice);
-                                out.push(...skipChoice);
-                            }
-                            else {
-                                out.push(...skipChoice);
-                                out.push(customValueChoice);
-                                out.push(...orderedMatches);
-                                if (loadMoreChoice)
-                                    out.push(loadMoreChoice);
-                            }
-                            // Capability hints only render when there are actual matches
-                            // (or no search term) so an empty-search view stays focused.
-                            if (capabilityHints.length > 0 &&
-                                (!trimmed || matches.length > 0)) {
-                                out.push(...capabilityHints);
-                            }
-                            return out;
-                        },
-                    });
-                }
-                else {
-                    // Multi-select (checkbox) and confirm prompts stay on
-                    // inquirer.prompt — search is single-select.
-                    if (isOptional && promptConfig.choices) {
-                        promptConfig.choices.unshift({
-                            name: chalk.dim("(Skip)"),
-                            value: SKIP_SENTINEL,
-                        });
-                    }
-                    if (hasMore && pageIterator && promptConfig.choices) {
-                        promptConfig.choices.push({
-                            name: chalk.dim("(Load more...)"),
-                            value: LOAD_MORE_SENTINEL,
-                        });
-                    }
-                    if (capabilityHints.length > 0 && promptConfig.choices) {
-                        promptConfig.choices.push(...capabilityHints);
-                    }
-                    // After loading more, jump cursor to first new item.
-                    // Offset by the number of injected choices before the data items (e.g. Skip).
-                    if (newItemsStartIndex >= 0 && promptConfig.choices) {
-                        const injectedBefore = isOptional ? 1 : 0;
-                        const adjustedIndex = newItemsStartIndex + injectedBefore;
-                        if (promptConfig.choices[adjustedIndex]) {
-                            promptConfig.default = promptConfig.choices[adjustedIndex].value;
-                        }
-                        newItemsStartIndex = -1;
-                    }
-                    const answers = await inquirer.prompt([promptConfig]);
-                    selected = answers[promptName];
-                }
-                if (selected === SKIP_SENTINEL) {
-                    return undefined;
-                }
-                if (selected === CUSTOM_VALUE_SENTINEL) {
-                    const customAnswer = await inquirer.prompt([
-                        {
-                            type: "input",
-                            name: promptName,
-                            message: `Enter ${promptLabel}${isOptional ? " (optional)" : ""}:`,
-                        },
-                    ]);
-                    const value = customAnswer[promptName];
-                    if (isOptional && (value === undefined || value === "")) {
-                        return undefined;
-                    }
-                    return value;
-                }
-                const wantsMore = Array.isArray(selected)
-                    ? selected.includes(LOAD_MORE_SENTINEL)
-                    : selected === LOAD_MORE_SENTINEL;
-                if (wantsMore && pageIterator) {
-                    if (Array.isArray(selected)) {
-                        selected = selected.filter((v) => v !== LOAD_MORE_SENTINEL);
-                    }
-                    const prevLength = items.length;
-                    this.startSpinner();
-                    this.debugLog("Fetching more options...");
-                    const next = await pageIterator.next();
-                    this.stopSpinner();
-                    if (!next.done && next.value) {
-                        items = [...items, ...next.value.data];
-                        hasMore = next.value.nextCursor != null;
-                        newItemsStartIndex = prevLength;
-                    }
-                    else {
-                        hasMore = false;
-                    }
-                    continue;
-                }
-                // Only the search-backed list path needs a manual filter call —
-                // @inquirer/search has no built-in filter hook. inquirer.prompt
-                // (the checkbox / confirm branch above) already applies the
-                // resolver's filter natively, so re-applying here would
-                // double-filter non-idempotent values.
-                return promptConfig.type === "list"
-                    ? this.applyPromptFilter(promptConfig.filter, selected)
-                    : selected;
-            }
-        }
-        else if (resolver.type === "fields") {
-            if (isOptional && !inArrayContext) {
-                this.stopSpinner();
-                const { confirm } = await inquirer.prompt([
-                    {
-                        type: "confirm",
-                        name: "confirm",
-                        message: `Add ${promptLabel}?`,
-                        default: false,
-                    },
-                ]);
-                if (!confirm) {
-                    return undefined;
-                }
-            }
-            return await this.resolveFieldsRecursively(resolver, context, param, { inArrayContext });
-        }
-        else if (resolver.type === "array") {
-            return await this.resolveArrayRecursively(resolver, context, param);
-        }
-        throw new Error(`Unknown resolver type for ${promptLabel}`);
-    }
-    async resolveFieldsRecursively(resolver, context, param, options = {}) {
-        const inputs = {};
-        let processedFieldKeys = new Set();
-        let iteration = 0;
-        const maxIterations = 10; // Prevent infinite loops
-        while (iteration < maxIterations) {
-            iteration++;
-            // Update context with current inputs so they're passed to listInputFields
-            const updatedContext = {
-                ...context,
-                resolvedParams: {
-                    ...context.resolvedParams,
-                    inputs,
-                },
-            };
-            this.debugLog(`Fetching input fields for ${param.name}${iteration > 1 ? ` (iteration ${iteration})` : ""}`);
-            this.startSpinner();
-            const rootFieldItems = await resolver.fetch(updatedContext.sdk, updatedContext.resolvedParams);
-            this.stopSpinner();
-            if (!rootFieldItems || rootFieldItems.length === 0) {
-                if (iteration === 1) {
-                    console.log(chalk.yellow(`No input fields required for this action.`));
-                }
-                break;
-            }
-            // Process fields recursively, maintaining fieldset structure
-            const fieldStats = await this.processFieldItems(rootFieldItems, inputs, processedFieldKeys, [], iteration, updatedContext, { inArrayContext: options.inArrayContext });
-            // If no new fields were processed, we're done
-            if (fieldStats.newRequired === 0 && fieldStats.newOptional === 0) {
-                break;
-            }
-            // If we only processed optional fields and skipped them, no need to re-fetch
-            if (fieldStats.newRequired === 0 && fieldStats.optionalSkipped) {
-                break;
-            }
-        }
-        if (iteration >= maxIterations) {
-            console.log(chalk.yellow(`\n⚠️  Maximum field resolution iterations reached. Some dynamic fields may not have been discovered.`));
-        }
-        // Apply transform if provided
-        if (resolver.transform) {
-            return resolver.transform(inputs);
-        }
-        return inputs;
-    }
-    /**
-     * Resolves an array parameter by repeatedly prompting for items until user says no
-     */
-    async resolveArrayRecursively(resolver, context, param) {
-        const items = [];
-        const minItems = resolver.minItems ?? 0;
-        const maxItems = resolver.maxItems ?? Infinity;
-        while (items.length < maxItems) {
-            const currentIndex = items.length;
-            // Skip confirmation if we haven't hit minItems yet - just collect the item
-            if (currentIndex >= minItems) {
-                this.stopSpinner();
-                const confirmAnswer = await inquirer.prompt([
-                    {
-                        type: "confirm",
-                        name: "addItem",
-                        message: `Add ${param.name}[${currentIndex}]?`,
-                        default: false,
-                    },
-                ]);
-                if (!confirmAnswer.addItem) {
-                    break;
-                }
-            }
-            // Fetch the inner resolver for this item
-            const innerResolver = await resolver.fetch(context.sdk, context.resolvedParams);
-            const itemValue = await this.resolveWithResolver(innerResolver, param, context, { arrayIndex: currentIndex });
-            items.push(itemValue);
-            // Update context with current array for subsequent iterations
-            context.resolvedParams = {
-                ...context.resolvedParams,
-                [param.name]: items,
-            };
-        }
-        if (items.length >= maxItems) {
-            console.log(chalk.gray(`Maximum of ${maxItems} items reached.`));
-        }
-        return items;
-    }
-    /**
-     * Recursively processes fieldsets and their fields, maintaining natural structure
-     * and creating nested inputs as needed (e.g., fieldset "foo" becomes inputs.foo = [{}])
-     */
-    async processFieldItems(items, targetInputs, processedFieldKeys, fieldsetPath = [], iteration = 1, context, options = {}) {
-        let newRequiredCount = 0;
-        let newOptionalCount = 0;
-        let optionalSkipped = false;
-        for (const item of items) {
-            const typedItem = item;
-            if (typedItem.type === "fieldset" && typedItem.fields && typedItem.key) {
-                // Show fieldset context to user
-                const fieldsetTitle = typedItem.title || typedItem.key;
-                const pathDisplay = fieldsetPath.length > 0 ? ` (in ${fieldsetPath.join(" > ")})` : "";
-                console.log(chalk.cyan(`\n📁 Processing fieldset: ${fieldsetTitle}${pathDisplay}`));
-                // Create fieldset array in target inputs if it doesn't exist
-                if (!targetInputs[typedItem.key]) {
-                    targetInputs[typedItem.key] = [{}];
-                }
-                // Process fields within this fieldset recursively
-                const fieldsetTarget = targetInputs[typedItem.key][0];
-                const nestedPath = [...fieldsetPath, fieldsetTitle];
-                const nestedStats = await this.processFieldItems(typedItem.fields, fieldsetTarget, processedFieldKeys, nestedPath, iteration, context, options);
-                newRequiredCount += nestedStats.newRequired;
-                newOptionalCount += nestedStats.newOptional;
-                if (nestedStats.optionalSkipped) {
-                    optionalSkipped = true;
-                }
-            }
-            else if (typedItem.type === "input_field" && typedItem.key) {
-                // Skip if already processed
-                if (processedFieldKeys.has(typedItem.key)) {
-                    continue;
-                }
-                const isRequired = typedItem.is_required || false;
-                if (isRequired) {
-                    // Process required field immediately
-                    newRequiredCount++;
-                    if (typedItem.resolver && context) {
-                        const param = {
-                            name: typedItem.key,
-                            path: [typedItem.key],
-                            schema: z.unknown(),
-                            isRequired: true,
-                        };
-                        targetInputs[typedItem.key] = await this.resolveWithResolver(typedItem.resolver, param, context, { isOptional: false });
-                    }
-                    else {
-                        await this.promptForField(typedItem, targetInputs, context);
-                    }
-                    processedFieldKeys.add(typedItem.key);
-                }
-                else {
-                    // Collect optional fields for batch processing
-                    newOptionalCount++;
-                }
-            }
-            // Skip info fields - they're for display only
-        }
-        // Handle optional fields after processing all required fields
-        if (newOptionalCount > 0) {
-            const optionalFields = items.filter((item) => {
-                const typedItem = item;
-                return (typedItem.type === "input_field" &&
-                    typedItem.key &&
-                    !typedItem.is_required &&
-                    !processedFieldKeys.has(typedItem.key));
-            });
-            if (optionalFields.length > 0) {
-                const pathContext = fieldsetPath.length > 0 ? ` in ${fieldsetPath.join(" > ")}` : "";
-                // In array context, prompt for all fields directly without confirmation
-                if (options.inArrayContext) {
-                    for (const field of optionalFields) {
-                        await this.promptForField(field, targetInputs, context);
-                        const typedField = field;
-                        processedFieldKeys.add(typedField.key);
-                    }
-                }
-                else {
-                    console.log(chalk.gray(`\nThere are ${optionalFields.length} ${iteration === 1 ? "" : "additional "}optional field(s) available${pathContext}.`));
-                    try {
-                        const shouldConfigureOptional = await inquirer.prompt([
-                            {
-                                type: "confirm",
-                                name: "configure",
-                                message: `Would you like to configure ${iteration === 1 ? "" : "these additional "}optional fields${pathContext}?`,
-                                default: false,
-                            },
-                        ]);
-                        if (shouldConfigureOptional.configure) {
-                            console.log(chalk.cyan(`\nOptional fields${pathContext}:`));
-                            for (const field of optionalFields) {
-                                await this.promptForField(field, targetInputs, context);
-                                const typedField = field;
-                                processedFieldKeys.add(typedField.key);
-                            }
-                        }
-                        else {
-                            optionalSkipped = true;
-                            // Mark these fields as processed even if skipped to avoid re-asking
-                            optionalFields.forEach((field) => {
-                                const typedField = field;
-                                processedFieldKeys.add(typedField.key);
-                            });
-                        }
-                    }
-                    catch (error) {
-                        if (this.isUserCancellation(error)) {
-                            console.log(chalk.yellow("\n\nOperation cancelled by user"));
-                            throw new ZapierCliUserCancellationError();
-                        }
-                        throw error;
-                    }
-                }
-            }
-        }
-        return {
-            newRequired: newRequiredCount,
-            newOptional: newOptionalCount,
-            optionalSkipped,
-        };
-    }
-    getNestedValue(obj, path) {
-        return path.reduce((current, key) => current?.[key], obj);
-    }
-    setNestedValue(obj, path, value) {
-        const lastKey = path[path.length - 1];
-        const parent = path.slice(0, -1).reduce((current, key) => {
-            const currentObj = current;
-            if (!(key in currentObj)) {
-                currentObj[key] = {};
-            }
-            return currentObj[key];
-        }, obj);
-        parent[lastKey] = value;
-    }
-    /**
-     * Extract and normalize field metadata from raw field object
-     */
-    extractFieldMetadata(field) {
-        const fieldObj = field;
-        const valueType = fieldObj.value_type || "string";
-        return {
-            key: fieldObj.key,
-            title: fieldObj.title || fieldObj.label || fieldObj.key,
-            description: fieldObj.description || fieldObj.helpText,
-            isRequired: fieldObj.is_required || false,
-            defaultValue: fieldObj.default_value ?? fieldObj.default,
-            valueType,
-            hasDropdown: fieldObj.format === "SELECT" || Boolean(fieldObj.choices),
-            isMultiSelect: Boolean(valueType === "array" ||
-                (fieldObj.items && fieldObj.items.type !== undefined)),
-            inlineChoices: fieldObj.choices,
-        };
-    }
-    /**
-     * Fetch a page of choices for a dropdown field
-     */
-    async fetchChoices(fieldMeta, inputs, context, cursor) {
-        try {
-            this.debugLog(cursor
-                ? `Fetching more choices for ${fieldMeta.title}`
-                : `Fetching choices for ${fieldMeta.title}`);
-            this.startSpinner();
-            const page = await context.sdk.listActionInputFieldChoices({
-                app: context.resolvedParams.app,
-                action: context.resolvedParams.action,
-                actionType: context.resolvedParams.actionType,
-                connection: context.resolvedParams.connection,
-                inputField: fieldMeta.key,
-                inputs,
-                ...(cursor && { cursor }),
-            });
-            this.stopSpinner();
-            const choices = page.data.map((choice) => ({
-                label: choice.label || choice.key || String(choice.value),
-                value: choice.value ?? choice.key,
-            }));
-            if (choices.length === 0 && !cursor) {
-                console.log(chalk.yellow(`No choices available for ${fieldMeta.title}`));
-            }
-            return {
-                choices,
-                nextCursor: page.nextCursor,
-            };
-        }
-        catch (error) {
-            this.stopSpinner();
-            console.warn(chalk.yellow(`Failed to fetch choices for ${fieldMeta.title}:`), error);
-            return { choices: [] };
-        }
-    }
-    /**
-     * Prompt user with choices (handles both single and multi-select with pagination).
-     * Single-select goes through @inquirer/search so users can type-to-filter long
-     * dropdowns (SELECT fields); multi-select stays on inquirer.prompt since search
-     * is single-select only.
-     */
-    async promptWithChoices({ fieldMeta, choices: initialChoices, nextCursor: initialCursor, inputs, context, }) {
-        this.stopSpinner();
-        const choices = [...initialChoices];
-        let nextCursor = initialCursor;
-        const LOAD_MORE_SENTINEL = Symbol("LOAD_MORE");
-        const SKIP_SENTINEL = Symbol("SKIP");
-        const CUSTOM_VALUE_SENTINEL = Symbol("CUSTOM_VALUE");
-        const message = `${fieldMeta.title}${fieldMeta.isRequired ? " (required)" : " (optional)"}:`;
-        while (true) {
-            let selectedValue;
-            if (!fieldMeta.isMultiSelect) {
-                const dataChoices = choices.map((c) => ({
-                    name: c.label,
-                    value: c.value,
-                }));
-                selectedValue = await search({
-                    message,
-                    source: (term) => {
-                        const trimmed = (term ?? "").trim();
-                        const lower = trimmed.toLowerCase();
-                        const matches = trimmed
-                            ? dataChoices.filter((c) => c.name.toLowerCase().includes(lower))
-                            : dataChoices;
-                        const out = [];
-                        const skipChoice = !fieldMeta.isRequired
-                            ? [{ name: chalk.dim("(Skip)"), value: SKIP_SENTINEL }]
-                            : [];
-                        // Dynamic dropdowns don't always return every valid value, so a
-                        // custom-value escape hatch is essential for SELECT fields.
-                        const customValueChoice = {
-                            name: chalk.dim("(Enter custom value)"),
-                            value: CUSTOM_VALUE_SENTINEL,
-                        };
-                        // Same ordering rule as the main dynamic-list source: never
-                        // let (Skip) be the first selectable when the user is
-                        // committed (filtered). Empty filtered results put Custom
-                        // and Load more above Skip so every constructive option
-                        // beats out skipping. Otherwise matches go first.
-                        const loadMoreChoice = nextCursor && context
-                            ? {
-                                name: chalk.dim("(Load more...)"),
-                                value: LOAD_MORE_SENTINEL,
-                            }
-                            : null;
-                        if (trimmed && matches.length > 0) {
-                            out.push(...matches);
-                            out.push(...skipChoice);
-                            out.push(customValueChoice);
-                            if (loadMoreChoice)
-                                out.push(loadMoreChoice);
-                        }
-                        else if (trimmed) {
-                            out.push(customValueChoice);
-                            if (loadMoreChoice)
-                                out.push(loadMoreChoice);
-                            out.push(...skipChoice);
-                        }
-                        else {
-                            out.push(...skipChoice);
-                            out.push(customValueChoice);
-                            out.push(...matches);
-                            if (loadMoreChoice)
-                                out.push(loadMoreChoice);
-                        }
-                        return out;
-                    },
-                });
-                if (selectedValue === SKIP_SENTINEL) {
-                    return undefined;
-                }
-                if (selectedValue === CUSTOM_VALUE_SENTINEL) {
-                    return await this.promptFreeForm(fieldMeta);
-                }
-            }
-            else {
-                const promptChoices = choices.map((c) => ({
-                    name: c.label,
-                    value: c.value,
-                }));
-                if (nextCursor) {
-                    promptChoices.push({
-                        name: chalk.dim("(Load more...)"),
-                        value: LOAD_MORE_SENTINEL,
-                    });
-                }
-                const promptConfig = {
-                    type: "checkbox",
-                    name: fieldMeta.key,
-                    message,
-                    choices: promptChoices,
-                    validate: (input) => {
-                        if (fieldMeta.isRequired && (!input || input.length === 0)) {
-                            return "At least one selection is required";
-                        }
-                        return true;
-                    },
-                };
-                const answer = await inquirer.prompt([promptConfig]);
-                selectedValue = answer[fieldMeta.key];
-            }
-            const wantsMore = fieldMeta.isMultiSelect
-                ? Array.isArray(selectedValue) &&
-                    selectedValue.includes(LOAD_MORE_SENTINEL)
-                : selectedValue === LOAD_MORE_SENTINEL;
-            if (wantsMore && nextCursor && context) {
-                if (fieldMeta.isMultiSelect && Array.isArray(selectedValue)) {
-                    selectedValue = selectedValue.filter((v) => v !== LOAD_MORE_SENTINEL);
-                }
-                const result = await this.fetchChoices(fieldMeta, inputs, context, nextCursor);
-                choices.push(...result.choices);
-                nextCursor = result.nextCursor;
-                continue;
-            }
-            return selectedValue;
-        }
-    }
-    /**
-     * Prompt user for free-form input (text or boolean)
-     */
-    async promptFreeForm(fieldMeta) {
-        const promptConfig = {
-            name: fieldMeta.key,
-            message: `${fieldMeta.title}${fieldMeta.isRequired ? " (required)" : " (optional)"}:`,
-        };
-        if (fieldMeta.valueType === "boolean") {
-            promptConfig.type = "confirm";
-            promptConfig.default =
-                fieldMeta.defaultValue !== undefined
-                    ? Boolean(fieldMeta.defaultValue)
-                    : undefined;
-        }
-        else if (fieldMeta.valueType === "array") {
-            promptConfig.type = "input";
-            promptConfig.default = fieldMeta.defaultValue;
-            promptConfig.message = `${fieldMeta.title}${fieldMeta.isRequired ? " (required)" : " (optional)"} (JSON array or comma-separated):`;
-            promptConfig.validate = (input) => {
-                if (fieldMeta.isRequired && !input) {
-                    return "This field is required";
-                }
-                return true;
-            };
-            promptConfig.filter = (input) => {
-                if (!input)
-                    return input;
-                const trimmed = input.trim();
-                if (trimmed.startsWith("[")) {
-                    try {
-                        return JSON.parse(trimmed);
-                    }
-                    catch {
-                        // Fall through to comma-separated
-                    }
-                }
-                return trimmed.split(",").map((s) => s.trim());
-            };
-        }
-        else {
-            promptConfig.type = "input";
-            promptConfig.default = fieldMeta.defaultValue;
-            promptConfig.validate = (input) => {
-                if (fieldMeta.isRequired && !input) {
-                    return "This field is required";
-                }
-                return true;
-            };
-        }
-        // Add help text if available
-        if (fieldMeta.description) {
-            promptConfig.prefix = chalk.gray(`ℹ  ${fieldMeta.description}\n`);
-        }
-        try {
-            const answer = await inquirer.prompt([promptConfig]);
-            return answer[fieldMeta.key];
-        }
-        catch (error) {
-            if (this.isUserCancellation(error)) {
-                console.log(chalk.yellow("\n\nOperation cancelled by user"));
-                throw new ZapierCliUserCancellationError();
-            }
-            throw error;
-        }
-    }
-    /**
-     * Store field value in inputs object with validation
-     */
-    storeFieldValue(inputs, key, value, isRequired) {
-        try {
-            if (value !== undefined && value !== "") {
-                inputs[key] = value;
-            }
-            else if (isRequired) {
-                throw new Error(`Required field ${key} cannot be empty`);
-            }
-        }
-        catch (error) {
-            if (this.isUserCancellation(error)) {
-                console.log(chalk.yellow("\n\nOperation cancelled by user"));
-                throw new ZapierCliUserCancellationError();
-            }
-            throw error;
-        }
-    }
-    async promptForField(field, inputs, context) {
-        const fieldMeta = this.extractFieldMetadata(field);
-        // Get choices - either inline or fetched from API
-        let choices = [];
-        let nextCursor;
-        if (fieldMeta.inlineChoices) {
-            // Use inline choices directly
-            choices = fieldMeta.inlineChoices;
-        }
-        else if (fieldMeta.hasDropdown && context) {
-            // Fetch choices from API
-            const result = await this.fetchChoices(fieldMeta, inputs, context);
-            choices = result.choices;
-            nextCursor = result.nextCursor;
-        }
-        // Prompt user based on field type
-        let selectedValue;
-        if (choices.length > 0) {
-            selectedValue = await this.promptWithChoices({
-                fieldMeta,
-                choices,
-                nextCursor,
-                inputs,
-                context,
-            });
-        }
-        else {
-            selectedValue = await this.promptFreeForm(fieldMeta);
-        }
-        // Store result
-        this.storeFieldValue(inputs, fieldMeta.key, selectedValue, fieldMeta.isRequired);
-    }
-    isUserCancellation(error) {
-        const errorObj = error;
-        return (errorObj?.name === "ExitPromptError" ||
-            errorObj?.message?.includes("User force closed") ||
-            errorObj?.isTTYError === true);
-    }
-    hasResolver(paramName, sdk, functionName) {
-        // Check plugin-specific resolvers first
-        if (functionName && typeof sdk.getRegistry === "function") {
-            const registry = sdk.getRegistry({ package: "cli" });
-            const functionInfo = registry.functions.find((f) => f.name === functionName);
-            if (functionInfo && functionInfo.resolvers?.[paramName]) {
-                return true;
-            }
-        }
-        // No global registry fallback
-        return false;
-    }
-    getResolver(paramName, sdk, functionName) {
-        // Check plugin-specific resolvers first
-        if (functionName && typeof sdk.getRegistry === "function") {
-            const registry = sdk.getRegistry({ package: "cli" });
-            const functionInfo = registry.functions.find((f) => f.name === functionName);
-            if (functionInfo && functionInfo.resolvers?.[paramName]) {
-                return functionInfo.resolvers[paramName];
-            }
-        }
-        // No global registry fallback
-        return null;
-    }
-    getLocalResolvers(sdk, functionName) {
-        if (!functionName || typeof sdk.getRegistry !== "function") {
-            return {};
-        }
-        const registry = sdk.getRegistry();
-        const functionInfo = registry.functions.find((f) => f.name === functionName);
-        return functionInfo?.resolvers || {};
-    }
-    getResolverConstants(sdk, functionName) {
-        if (!functionName || typeof sdk.getRegistry !== "function") {
-            return {};
-        }
-        const registry = sdk.getRegistry();
-        const functionInfo = registry.functions.find((f) => f.name === functionName);
-        const resolvers = functionInfo?.resolvers ?? {};
-        const constants = {};
-        for (const [key, resolver] of Object.entries(resolvers)) {
-            if (resolver &&
-                typeof resolver === "object" &&
-                resolver.type === "constant") {
-                constants[key] = resolver.value;
-            }
-        }
-        return constants;
-    }
-}