@sanity/runtime-cli 17.8.0-next.g5972da4 → 17.9.0-blueprinit.g14aaebd

package/dist/cores/blueprinit/prompts.js

@@ -0,0 +1,42 @@
+import { confirm, input } from '@inquirer/prompts';
+import { DEFAULT_STUDIO_NAME, slugify } from '../../actions/blueprinit/manifest.js';
+/**
+ * Resource names must be unique within a Blueprint, so report every name used twice.
+ *
+ * The generated names cannot collide with each other, because each one carries its
+ * resource type. A dataset name or a `--studio-name` value can still land on one.
+ */
+export function duplicateResourceNames(names) {
+    const seen = new Set();
+    const duplicates = new Set();
+    for (const name of names) {
+        if (seen.has(name))
+            duplicates.add(name);
+        else
+            seen.add(name);
+    }
+    return [...duplicates];
+}
+export async function confirmUnlessSkipped(flags, interactive, message) {
+    if (flags.yes || !interactive)
+        return true;
+    return await confirm({ message, default: true });
+}
+/** The new Stack's name, which is also the hosted Studio slug. */
+export async function promptForStackName(flags, interactive, defaultName) {
+    if (flags.stackName)
+        return slugify(flags.stackName) || defaultName;
+    if (flags.yes || !interactive)
+        return defaultName;
+    const answer = await input({
+        message: 'Name your Stack and hosted Studio?',
+        default: defaultName,
+    });
+    return slugify(answer) || defaultName;
+}
+/** The Blueprint-local Studio name, which is also its directory under `studios/`. */
+export function studioResourceName(flags) {
+    if (!flags.studioName)
+        return DEFAULT_STUDIO_NAME;
+    return slugify(flags.studioName) || DEFAULT_STUDIO_NAME;
+}

package/dist/cores/blueprinit/results.d.ts

@@ -0,0 +1,8 @@
+import type { CoreResult } from '../index.js';
+/** A failed step, in the shape every helper in this flow reports. */
+export interface FlowError {
+    message: string;
+    suggestions?: string[];
+}
+/** Turn a failed step into the result the command returns. */
+export declare function coreFailure(error: FlowError): CoreResult;

package/dist/cores/blueprinit/results.js

@@ -0,0 +1,4 @@
+/** Turn a failed step into the result the command returns. */
+export function coreFailure(error) {
+    return { success: false, error: error.message, suggestions: error.suggestions };
+}

package/dist/cores/blueprinit/selection.d.ts

@@ -0,0 +1,15 @@
+import type { Dataset } from '../../actions/sanity/datasets.js';
+import type { GroupedProjects, Project } from '../../actions/sanity/projects.js';
+import type { Result } from '../../utils/types.js';
+interface SelectionError {
+    message: string;
+    suggestions?: string[];
+}
+export declare function chooseOrganization(groups: GroupedProjects[], organizationId: string | undefined, interactive: boolean): Promise<Result<GroupedProjects, SelectionError>>;
+export declare function chooseProject(projects: Project[], projectId: string | undefined, organizationName: string, interactive: boolean): Promise<Result<Project, SelectionError>>;
+export declare function chooseDataset(datasets: Dataset[], datasetName: string | undefined, projectName: string, interactive: boolean): Promise<Result<Dataset, SelectionError>>;
+export declare function findProject(groups: GroupedProjects[], projectId: string): {
+    organization: GroupedProjects['organization'];
+    project: Project;
+} | undefined;
+export {};

package/dist/cores/blueprinit/selection.js

@@ -0,0 +1,90 @@
+import { select } from '@inquirer/prompts';
+export async function chooseOrganization(groups, organizationId, interactive) {
+    if (groups.length === 0) {
+        return failure('No organizations found for this account.');
+    }
+    if (organizationId) {
+        const organization = groups.find((group) => group.organization.id === organizationId);
+        return organization
+            ? { ok: true, value: organization }
+            : failure(`No organization "${organizationId}" found for this account.`);
+    }
+    if (groups.length === 1)
+        return { ok: true, value: groups[0] };
+    if (!interactive) {
+        return failure('Multiple organizations found.', ['Pass --organization-id <id> to choose one.']);
+    }
+    const selectedId = await select({
+        message: 'Choose a Sanity organization:',
+        choices: groups.map(({ organization, projects }) => ({
+            name: organization.name,
+            value: organization.id,
+            description: `${projects?.length ?? 0} projects`,
+        })),
+    });
+    const selected = groups.find(({ organization }) => organization.id === selectedId);
+    return selected ? { ok: true, value: selected } : failure('Organization not found.');
+}
+export async function chooseProject(projects, projectId, organizationName, interactive) {
+    if (projects.length === 0) {
+        return failure(`No projects found in ${organizationName}.`);
+    }
+    if (projectId) {
+        const project = projects.find(({ id }) => id === projectId);
+        return project
+            ? { ok: true, value: project }
+            : failure(`No project "${projectId}" found in ${organizationName}.`);
+    }
+    if (projects.length === 1)
+        return { ok: true, value: projects[0] };
+    if (!interactive) {
+        return failure('Multiple projects found.', ['Pass --project-id <id> to choose one.']);
+    }
+    const selectedId = await select({
+        message: 'Choose a Sanity project:',
+        choices: projects.map((project) => ({ name: project.displayName, value: project.id })),
+    });
+    const selected = projects.find(({ id }) => id === selectedId);
+    return selected ? { ok: true, value: selected } : failure('Project not found.');
+}
+export async function chooseDataset(datasets, datasetName, projectName, interactive) {
+    if (datasets.length === 0) {
+        return failure(`No datasets found in ${projectName}.`);
+    }
+    if (datasetName) {
+        const dataset = datasets.find(({ name }) => name === datasetName);
+        return dataset
+            ? { ok: true, value: dataset }
+            : failure(`No dataset "${datasetName}" found in ${projectName}.`);
+    }
+    if (datasets.length === 1)
+        return { ok: true, value: datasets[0] };
+    if (!interactive) {
+        return failure('Multiple datasets found.', ['Pass --dataset <name> to choose one.']);
+    }
+    const production = datasets.find(({ name }) => name === 'production');
+    const orderedDatasets = production
+        ? [production, ...datasets.filter(({ name }) => name !== 'production')]
+        : datasets;
+    const selectedName = await select({
+        message: 'Choose a Sanity dataset:',
+        choices: orderedDatasets.map((dataset) => ({
+            name: dataset.name,
+            value: dataset.name,
+            description: dataset.aclMode,
+        })),
+    });
+    const selected = datasets.find(({ name }) => name === selectedName);
+    return selected ? { ok: true, value: selected } : failure('Dataset not found.');
+}
+export function findProject(groups, projectId) {
+    for (const { organization, projects = [] } of groups) {
+        const project = projects.find(({ id }) => id === projectId);
+        if (project)
+            return { organization, project };
+    }
+    return undefined;
+}
+function failure(message, suggestions) {
+    return { ok: false, error: { message, suggestions } };
+}

package/dist/cores/blueprinit/stack-name.d.ts

@@ -0,0 +1,39 @@
+import type { Logger } from '../../utils/logger.js';
+import type { BlueprinitFlags } from './types.js';
+interface TakenNamesOptions {
+    token: string;
+    organizationId: string;
+    log: Logger;
+}
+/**
+ * Stack names already used in the organization.
+ *
+ * Returns nothing when the listing fails. A token that cannot read Stacks is not a reason
+ * to stop, because the create call reports the same conflict a moment later.
+ */
+export declare function takenStackNames(options: TakenNamesOptions): Promise<Set<string>>;
+interface ChooseStackNameOptions {
+    flags: BlueprinitFlags;
+    interactive: boolean;
+    defaultName: string;
+    taken: Set<string>;
+    log: Logger;
+}
+type ChooseStackNameResult = {
+    ok: true;
+    value: string;
+} | {
+    ok: false;
+    error: string;
+    suggestions: string[];
+};
+/**
+ * A Stack name the organization does not already hold.
+ *
+ * Asks again rather than failing, because the conflict is only visible after `init` has
+ * written every local file.
+ */
+export declare function chooseStackName(options: ChooseStackNameOptions): Promise<ChooseStackNameResult>;
+/** `field-notes-production`, then `field-notes-production-2`, until one is free. */
+export declare function nextFreeName(name: string, taken: Set<string>): string;
+export {};

package/dist/cores/blueprinit/stack-name.js

@@ -0,0 +1,56 @@
+import { listStacks } from '../../actions/blueprints/stacks.js';
+import { warn } from '../../utils/display/presenters.js';
+import { promptForStackName } from './prompts.js';
+/**
+ * Stack names already used in the organization.
+ *
+ * Returns nothing when the listing fails. A token that cannot read Stacks is not a reason
+ * to stop, because the create call reports the same conflict a moment later.
+ */
+export async function takenStackNames(options) {
+    const { token, organizationId, log } = options;
+    const result = await listStacks({ token, scopeType: 'organization', scopeId: organizationId }, log);
+    if (!result.ok) {
+        log.verbose(`Could not list Stacks to check the name: ${result.error}`);
+        return new Set();
+    }
+    return new Set(result.stacks.map(({ name }) => name));
+}
+/**
+ * A Stack name the organization does not already hold.
+ *
+ * Asks again rather than failing, because the conflict is only visible after `init` has
+ * written every local file.
+ */
+export async function chooseStackName(options) {
+    const { flags, interactive, defaultName, taken, log } = options;
+    const suggested = nextFreeName(defaultName, taken);
+    if (suggested !== defaultName) {
+        log(warn(`A Stack named "${defaultName}" already exists. Suggesting "${suggested}".`));
+    }
+    let name = await promptForStackName(flags, interactive, suggested);
+    while (taken.has(name)) {
+        // Only a --stack-name value can be taken here; every other path starts from a free name.
+        if (!interactive || flags.yes || flags.stackName) {
+            return {
+                ok: false,
+                error: `A Stack named "${name}" already exists in this organization.`,
+                suggestions: [`Pass --stack-name with a different value, such as ${suggested}.`],
+            };
+        }
+        log(warn(`A Stack named "${name}" already exists in this organization.`));
+        name = await promptForStackName({}, interactive, nextFreeName(name, taken));
+    }
+    return { ok: true, value: name };
+}
+/** `field-notes-production`, then `field-notes-production-2`, until one is free. */
+export function nextFreeName(name, taken) {
+    if (!taken.has(name))
+        return name;
+    for (let suffix = 2; suffix < 100; suffix += 1) {
+        const candidate = `${name}-${suffix}`;
+        if (!taken.has(candidate))
+            return candidate;
+    }
+    return name;
+}

package/dist/cores/blueprinit/target.d.ts

@@ -0,0 +1,33 @@
+import type { Result } from '../../utils/types.js';
+interface TargetError {
+    message: string;
+    suggestions?: string[];
+}
+export declare function isEmptyDirectory(dir: string): boolean;
+/**
+ * What the directory prompt offers.
+ *
+ * The current directory when it is free, and a new directory named for the project when it
+ * is not, so accepting the default never writes a scaffold beside unrelated files.
+ */
+export declare function defaultTargetPath(dir: string, baseName: string): string;
+/**
+ * Where to scaffold, asked rather than assumed.
+ *
+ * An unattended run keeps the current directory. Relocating a scaffold with nobody watching
+ * would move files a script expects to find where it started.
+ */
+export declare function promptForTargetDirectory(dir: string, baseName: string, interactive: boolean): Promise<string>;
+/**
+ * Resolve the answer against the starting directory and refuse a target that is already
+ * something else: a file, a Blueprint, or a Studio that adoption should handle instead.
+ */
+export declare function resolveTargetDirectory(dir: string, answer: string, bin: string): Result<string, TargetError>;
+/**
+ * The `cd` the printed next steps need, or nothing when the files landed here.
+ *
+ * Measured from the process working directory, not from the flow's starting directory,
+ * because a directory argument moves the target without moving the reader.
+ */
+export declare function relativeTargetPath(target: string, from?: string): string | undefined;
+export {};

package/dist/cores/blueprinit/target.js

@@ -0,0 +1,80 @@
+import { existsSync, readdirSync, statSync } from 'node:fs';
+import { isAbsolute, relative, resolve } from 'node:path';
+import { cwd } from 'node:process';
+import { input } from '@inquirer/prompts';
+import { detectStudio } from '../../actions/blueprinit/studio.js';
+import { findBlueprintFile } from '../../actions/blueprints/blueprint.js';
+/** Entries that say nothing about whether a directory is in use. */
+const IGNORED_ENTRIES = new Set(['.git', '.DS_Store']);
+export function isEmptyDirectory(dir) {
+    try {
+        return readdirSync(dir).every((entry) => IGNORED_ENTRIES.has(entry));
+    }
+    catch {
+        // A directory that does not exist yet has nothing to overwrite.
+        return true;
+    }
+}
+/**
+ * What the directory prompt offers.
+ *
+ * The current directory when it is free, and a new directory named for the project when it
+ * is not, so accepting the default never writes a scaffold beside unrelated files.
+ */
+export function defaultTargetPath(dir, baseName) {
+    return isEmptyDirectory(dir) ? '.' : `./${baseName}`;
+}
+/**
+ * Where to scaffold, asked rather than assumed.
+ *
+ * An unattended run keeps the current directory. Relocating a scaffold with nobody watching
+ * would move files a script expects to find where it started.
+ */
+export async function promptForTargetDirectory(dir, baseName, interactive) {
+    if (!interactive)
+        return '.';
+    const fallback = defaultTargetPath(dir, baseName);
+    const answer = await input({ message: 'Where should the files go?', default: fallback });
+    return answer.trim() || fallback;
+}
+/**
+ * Resolve the answer against the starting directory and refuse a target that is already
+ * something else: a file, a Blueprint, or a Studio that adoption should handle instead.
+ */
+export function resolveTargetDirectory(dir, answer, bin) {
+    const target = isAbsolute(answer) ? answer : resolve(dir, answer);
+    if (existsSync(target) && !statSync(target).isDirectory()) {
+        return { ok: false, error: { message: `${answer} is not a directory.` } };
+    }
+    const blueprint = findBlueprintFile(target);
+    if (blueprint) {
+        return {
+            ok: false,
+            error: {
+                message: `A Blueprint already exists in ${answer} (${blueprint.fileName}).`,
+                suggestions: [`Review it with: npx ${bin} blueprints doctor`],
+            },
+        };
+    }
+    const studio = detectStudio(target);
+    if (studio) {
+        return {
+            ok: false,
+            error: {
+                message: `${answer} already holds a Studio (${studio.configFile}).`,
+                suggestions: [`Wrap it in a Blueprint with: npx ${bin} init ${answer}`],
+            },
+        };
+    }
+    return { ok: true, value: target };
+}
+/**
+ * The `cd` the printed next steps need, or nothing when the files landed here.
+ *
+ * Measured from the process working directory, not from the flow's starting directory,
+ * because a directory argument moves the target without moving the reader.
+ */
+export function relativeTargetPath(target, from = cwd()) {
+    const path = relative(from, target);
+    return path === '' ? undefined : path;
+}

package/dist/cores/blueprinit/types.d.ts

@@ -0,0 +1,20 @@
+import type { Logger } from '../../utils/logger.js';
+export interface BlueprinitFlags {
+    yes?: boolean;
+    organizationId?: string;
+    projectId?: string;
+    /** Display name for a project to create, instead of using one that exists. */
+    createProject?: string;
+    datasetName?: string;
+    stackName?: string;
+    studioName?: string;
+}
+export interface BlueprinitFlowOptions {
+    bin: string;
+    dir: string;
+    /** True when a directory argument named the target, so the flow must not ask for one. */
+    targetProvided: boolean;
+    flags: BlueprinitFlags;
+    log: Logger;
+    token: string;
+}

package/dist/cores/blueprinit/types.js

@@ -0,0 +1 @@
+export {};

package/dist/cores/blueprinit.d.ts

@@ -0,0 +1,7 @@
+import type { BlueprinitFlags } from './blueprinit/types.js';
+import type { CoreConfig, CoreResult } from './index.js';
+export interface BlueprinitOptions extends CoreConfig {
+    dir?: string;
+    flags?: BlueprinitFlags;
+}
+export declare function blueprinitCore(options: BlueprinitOptions): Promise<CoreResult>;

package/dist/cores/blueprinit.js

@@ -0,0 +1,64 @@
+import { existsSync, statSync } from 'node:fs';
+import { cwd } from 'node:process';
+import { detectStudio } from '../actions/blueprinit/studio.js';
+import { findBlueprintFile } from '../actions/blueprints/blueprint.js';
+import { readConfigFile } from '../actions/blueprints/config.js';
+import { validTokenOrErrorMessage } from '../utils/validated-token.js';
+import { adoptFlow } from './blueprinit/adopt.js';
+import { freshFlow } from './blueprinit/fresh.js';
+export async function blueprinitCore(options) {
+    const { bin, log, flags = {}, dir = cwd() } = options;
+    try {
+        // findBlueprintFile answers with any file it is handed, so refuse a file target first.
+        if (existsSync(dir) && !statSync(dir).isDirectory()) {
+            return {
+                success: false,
+                error: `${dir} is not a directory.`,
+                suggestions: ['Pass a directory to initialize, or no argument to use this one.'],
+            };
+        }
+        const existingBlueprint = findBlueprintFile(dir);
+        if (existingBlueprint) {
+            const blueprintConfig = readConfigFile(existingBlueprint.blueprintFilePath);
+            if (!blueprintConfig?.stackId) {
+                return {
+                    success: false,
+                    error: `A Blueprint exists here (${existingBlueprint.fileName}), but it is not connected to a Stack.`,
+                    suggestions: [`Finish setup with: npx ${bin} blueprints init`],
+                };
+            }
+            log(`A blueprint already exists here (${existingBlueprint.fileName}).`);
+            log('');
+            log('Use these instead:');
+            log(`  npx ${bin} blueprints config --edit`);
+            log(`  npx ${bin} blueprints doctor`);
+            return {
+                success: true,
+                json: { alreadyInitialized: true, blueprintFile: existingBlueprint.fileName },
+            };
+        }
+        const tokenCheck = await validTokenOrErrorMessage(log);
+        if (!tokenCheck.ok) {
+            return {
+                success: false,
+                error: 'No Sanity session found.',
+                suggestions: ['Sign in first: npx sanity login', 'Then run init again.'],
+            };
+        }
+        log('Setting up your Sanity workspace.');
+        log('');
+        const flowOptions = {
+            bin,
+            dir,
+            targetProvided: Boolean(options.dir),
+            flags,
+            log,
+            token: tokenCheck.value,
+        };
+        const studio = detectStudio(dir);
+        return studio ? await adoptFlow({ ...flowOptions, studio }) : await freshFlow(flowOptions);
+    }
+    catch (error) {
+        return { success: false, error: error instanceof Error ? error.message : String(error) };
+    }
+}

package/dist/cores/functions/test.js

@@ -3,6 +3,7 @@ import { testAction } from '../../actions/functions/test.js';
 import config from '../../config.js';
 import { STEP_PHASE_GLYPH } from '../../constants.js';
 import { resolveDeployedResources } from '../../utils/blueprints/resolve-deployed-resources.js';
+import { createDurableJsonCollector } from '../../utils/functions/durable-logs.js';
 import { findFunctionInResources, getFunctionNames } from '../../utils/functions/find.js';
 import { runFunction } from '../../utils/functions/invoke/nested.js';
 import { buildContext, buildInvokeOptions, collectInvokeInput, defaultInvocationDeps, resolveInvocationPlan, } from '../../utils/functions/invoke/resolve-invoke-type.js';
@@ -12,19 +13,25 @@ import { isEventType, } from '../../utils/types.js';
  * @param events
  */
 function renderStepTimeline(events) {
-    return events
-        .filter((event) => event.phase !== 'start')
-        .map((event) => {
+    const lines = [];
+    for (const event of events) {
+        if (event.kind === 'log') {
+            lines.push(`${event.timestamp} ${event.level.toUpperCase()} ${event.message}`);
+            continue;
+        }
+        if (event.phase === 'start')
+            continue;
         const glyph = STEP_PHASE_GLYPH[event.phase] ?? '•';
         const duration = typeof event.durationMs === 'number' ? ` (${Math.round(event.durationMs)}ms)` : '';
         const detail = event.phase === 'error' && event.error ? ` ${event.error.message}` : '';
-        return `  ${glyph} ${event.name} [${event.kind}]${duration}${detail}`;
-    });
+        lines.push(`  ${glyph} ${event.name} [${event.kind}]${duration}${detail}`);
+    }
+    return lines;
 }
 export async function functionTestCore(options) {
     const { blueprint, log, error, args, flags, helpText } = options;
     const { name: fnName } = args;
-    const { event, timeout, api, 'with-user-token': withUserToken } = flags;
+    const { event, timeout, api, 'with-user-token': withUserToken, 'no-wait': noWait } = flags;
     const { 'project-id': projectId = blueprint?.projectId, 'organization-id': organizationId = blueprint?.organizationId, } = flags;
     if (!fnName) {
         const functionNames = getFunctionNames(blueprint.resources);
@@ -77,10 +84,17 @@ export async function functionTestCore(options) {
         // Records each nested context.invoke() so they can be surfaced in order after the spinner resolves.
         const nestedRuns = [];
         let nestedOrder = 0;
-        const stepEvents = [];
+        const durableJson = createDurableJsonCollector();
         const onStepEvent = plan.isDurable
             ? (event) => {
-                stepEvents.push(event);
+                if (flags.json) {
+                    durableJson.record(event);
+                    return;
+                }
+                for (const line of renderStepTimeline([event])) {
+                    if (line !== null)
+                        log(line);
+                }
             }
             : undefined;
         /**
@@ -120,6 +134,7 @@ export async function functionTestCore(options) {
             depth: 0,
             callStack: [fnName],
             onStepEvent,
+            noWait,
         });
         if (error) {
             spinner.fail('Function execution failed.');
@@ -131,12 +146,6 @@ export async function functionTestCore(options) {
             logNestedRuns();
             const errorMessage = error.stack || error.message || error.name;
             const isTimeout = error.message?.includes('Timeout');
-            if (plan.isDurable && stepEvents.length > 0) {
-                log('Steps:');
-                for (const line of renderStepTimeline(stepEvents)) {
-                    log(line);
-                }
-            }
             return {
                 success: false,
                 error: errorMessage,
@@ -147,20 +156,26 @@ export async function functionTestCore(options) {
             };
         }
         spinner.succeed('Function execution succeeded.');
-        log('Logs:');
-        log(logs || '');
-        logNestedRuns();
-        if (response) {
-            log('Response:');
-            log(JSON.stringify(response, null, 2));
-        }
-        if (plan.isDurable && stepEvents.length > 0) {
-            log('Steps:');
-            for (const line of renderStepTimeline(stepEvents)) {
-                log(line);
+        if (!plan.isDurable) {
+            log('Logs:');
+            log(logs || '');
+            logNestedRuns();
+            if (response) {
+                log('Response:');
+                log(JSON.stringify(response, null, 2));
             }
         }
-        return { success: true, json: { response, logs } };
+        const durableResult = durableJson.result();
+        return {
+            success: true,
+            json: plan.isDurable
+                ? {
+                    response: response ?? null,
+                    steps: durableResult.steps,
+                    logs: durableResult.logs,
+                }
+                : { response, logs },
+        };
     }
     catch (error) {
         return {

package/dist/utils/display/intro.d.ts

@@ -0,0 +1,6 @@
+/** A left-to-right reveal of the wordmark; the last frame is the finished line. */
+export declare function introFrames(): string[];
+/** Print the intro, animated when the terminal can show it and static when it cannot. */
+export declare function playIntro({ json }?: {
+    json?: boolean;
+}): Promise<void>;

package/dist/utils/display/intro.js

@@ -0,0 +1,63 @@
+import { env, stdout } from 'node:process';
+import { onExit } from 'signal-exit';
+import { isInteractive } from '../interactive.js';
+import { styleText } from '../style-text.js';
+const INDENT = '  ';
+const WORDMARK = 'sanity';
+const TAIL = ' with blueprints';
+/** The leading edge of the reveal, densest first. */
+const GRADIENT = ['▓', '▒', '░'];
+const REVEAL_PER_FRAME = 1;
+const FRAME_MS = 45;
+/** Time the finished wordmark holds before the command's own output follows. */
+const HOLD_MS = 250;
+const HIDE_CURSOR = '\x1b[?25l';
+const SHOW_CURSOR = '\x1b[?25h';
+const CLEAR_LINE = '\x1b[2K';
+function style(revealed, edge) {
+    const wordmark = revealed.slice(0, WORDMARK.length);
+    const tail = revealed.slice(WORDMARK.length);
+    return INDENT + styleText(['bold', 'red'], wordmark) + styleText('dim', tail + edge);
+}
+/** A left-to-right reveal of the wordmark; the last frame is the finished line. */
+export function introFrames() {
+    const full = WORDMARK + TAIL;
+    const frames = [];
+    for (let revealed = REVEAL_PER_FRAME; revealed < full.length; revealed += REVEAL_PER_FRAME) {
+        const edge = GRADIENT.slice(0, Math.min(GRADIENT.length, full.length - revealed)).join('');
+        frames.push(style(full.slice(0, revealed), edge));
+    }
+    frames.push(style(full, ''));
+    return frames;
+}
+function animates() {
+    return isInteractive && env.TERM !== 'dumb' && !env.CI;
+}
+const sleep = (ms) => new Promise((resolve) => setTimeout(resolve, ms));
+/** Print the intro, animated when the terminal can show it and static when it cannot. */
+export async function playIntro({ json = false } = {}) {
+    if (json)
+        return;
+    const frames = introFrames();
+    const finished = frames.at(-1) ?? '';
+    if (!animates()) {
+        stdout.write(`\n${finished}\n\n`);
+        return;
+    }
+    stdout.write(`\n${HIDE_CURSOR}`);
+    const cancelExitHook = onExit(() => {
+        stdout.write(SHOW_CURSOR);
+    });
+    try {
+        for (const frame of frames) {
+            stdout.write(`\r${CLEAR_LINE}${frame}`);
+            await sleep(FRAME_MS);
+        }
+        await sleep(HOLD_MS);
+        stdout.write('\n\n');
+    }
+    finally {
+        stdout.write(SHOW_CURSOR);
+        cancelExitHook();
+    }
+}