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

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

@@ -0,0 +1,34 @@
+import { type DatasetAction } from '../../actions/blueprinit/manifest.js';
+import type { Logger } from '../../utils/logger.js';
+interface BlueprintPreviewOptions {
+    log: Logger;
+    /** Absent when this run creates the project, because the ID exists only afterwards. */
+    projectId?: string;
+    organizationName: string;
+    projectName: string;
+    datasetName: string;
+    studioName: string;
+    studioOrigin: string;
+    studioSource: string;
+    stackName: string;
+    functionName?: string;
+    datasetAction: DatasetAction;
+    /** Set when this run creates the project before it writes anything. */
+    createsProject?: boolean;
+}
+/** The counts `blueprints plan` will report for this Blueprint. */
+export interface PreviewCounts {
+    attaches: number;
+    creates: number;
+}
+/**
+ * Print the plan, then report the counts it showed.
+ *
+ * The counts come from the rows that were printed, so the table and the totals in the
+ * next steps cannot disagree.
+ */
+export declare function printBlueprintPreview(options: BlueprintPreviewOptions): PreviewCounts;
+/** A local change: a marker, the path, and what the file is for. */
+export type FileLine = [marker: '+' | '~', path: string, description?: string];
+export declare function fileLines(lines: FileLine[]): string[];
+export {};

package/dist/cores/blueprinit/preview.js

@@ -0,0 +1,110 @@
+import { corsResourceName } from '../../actions/blueprinit/manifest.js';
+import { styleText } from '../../utils/style-text.js';
+import { renderRows } from './columns.js';
+/** The icon and colour `blueprints plan` uses for the same action. */
+const ACTION_STYLE = {
+    attach: { icon: '←', color: 'blue' },
+    create: { icon: '+', color: 'green' },
+};
+const RETAIN_SUFFIX = 'retain on Stack removal';
+const RETAIN = `on deploy; ${RETAIN_SUFFIX}`;
+function previewResources(options) {
+    const resources = [
+        {
+            action: 'attach',
+            kind: 'Project',
+            name: options.projectId
+                ? `${options.projectName} (${options.projectId})`
+                : options.projectName,
+            detail: options.projectId ? RETAIN : `once created, ${RETAIN_SUFFIX}`,
+        },
+        {
+            action: options.datasetAction,
+            kind: 'Dataset',
+            name: options.datasetName,
+            detail: options.datasetAction === 'attach' ? RETAIN : `on deploy; ${RETAIN_SUFFIX}`,
+        },
+        {
+            action: 'create',
+            kind: 'CORS Origin',
+            name: corsResourceName(options.studioName),
+            detail: `for ${options.studioOrigin} on deploy`,
+        },
+        {
+            action: 'create',
+            kind: 'Studio',
+            name: options.studioName,
+            // The origin is on the CORS line directly above, so it is not repeated here.
+            detail: `from ${options.studioSource} on deploy`,
+        },
+    ];
+    if (options.functionName) {
+        resources.push({
+            action: 'create',
+            kind: 'Function',
+            name: options.functionName,
+            detail: 'on deploy',
+        });
+    }
+    return resources;
+}
+function actionRow(resource) {
+    const { icon, color } = ACTION_STYLE[resource.action];
+    return [
+        { text: icon, style: ['bold', color] },
+        { text: resource.action, style: color },
+        { text: resource.kind },
+        { text: resource.name, style: 'bold', gap: 2 },
+        { text: resource.detail, style: 'dim' },
+    ];
+}
+/**
+ * Print the plan, then report the counts it showed.
+ *
+ * The counts come from the rows that were printed, so the table and the totals in the
+ * next steps cannot disagree.
+ */
+export function printBlueprintPreview(options) {
+    const resources = previewResources(options);
+    const remote = [];
+    if (options.createsProject) {
+        remote.push({
+            action: 'create',
+            kind: 'Project',
+            name: options.projectName,
+            detail: `in ${options.organizationName}, before any file is written`,
+        });
+    }
+    remote.push({
+        action: 'create',
+        kind: 'Stack',
+        name: options.stackName,
+        detail: `in ${options.organizationName} (empty, organization scope)`,
+    });
+    // One call across both blocks, so one set of widths makes the two read as one table.
+    const rows = renderRows([...resources, ...remote].map(actionRow));
+    const remoteRows = rows.slice(resources.length);
+    options.log(styleText('bold', 'Blueprint plan:'));
+    for (const row of rows.slice(0, resources.length))
+        options.log(row);
+    options.log('');
+    options.log(styleText('bold', remote.length === 1 ? 'One remote change now:' : 'Remote changes now:'));
+    for (const row of remoteRows)
+        options.log(row);
+    options.log('');
+    return {
+        attaches: resources.filter(({ action }) => action === 'attach').length,
+        creates: resources.filter(({ action }) => action === 'create').length,
+    };
+}
+export function fileLines(lines) {
+    return renderRows(lines.map(([marker, path, description]) => {
+        const cells = [
+            { text: marker, style: ['bold', marker === '+' ? 'green' : 'yellow'] },
+            { text: path, style: 'bold', gap: 3 },
+        ];
+        if (description)
+            cells.push({ text: description, style: 'dim' });
+        return cells;
+    }));
+}

package/dist/cores/blueprinit/project-choice.d.ts

@@ -0,0 +1,28 @@
+import type { Project } from '../../actions/sanity/projects.js';
+import type { Result } from '../../utils/types.js';
+import type { FlowError } from './results.js';
+import type { BlueprinitFlags } from './types.js';
+export declare const DEFAULT_DATASET_NAME = "production";
+export declare function datasetNameError(name: string): string | undefined;
+/** What the fresh flow attaches a Blueprint to: a project that exists, or one to create. */
+export type ProjectChoice = {
+    create: false;
+} | {
+    create: true;
+    displayName: string;
+    datasetName: string;
+};
+interface ChooseProjectSourceOptions {
+    flags: BlueprinitFlags;
+    interactive: boolean;
+    projects: Project[];
+    organizationName: string;
+}
+/**
+ * Whether this run creates a project.
+ *
+ * `--create-project` decides it without asking. An organization with no projects has
+ * nothing to select, so creation is the only way forward there.
+ */
+export declare function chooseProjectSource(options: ChooseProjectSourceOptions): Promise<Result<ProjectChoice, FlowError>>;
+export {};

package/dist/cores/blueprinit/project-choice.js

@@ -0,0 +1,82 @@
+import { input, select } from '@inquirer/prompts';
+export const DEFAULT_DATASET_NAME = 'production';
+/**
+ * The dataset name rule the projects API enforces, with `convert: false`.
+ *
+ * Underscores are legal, so a name is checked and refused rather than slugified. The
+ * pattern also rejects a single character, which is why a short name fails here and not
+ * at deploy.
+ */
+const DATASET_NAME_PATTERN = /^[a-z0-9][-_a-z0-9]+$/;
+export function datasetNameError(name) {
+    if (name.length > 64)
+        return 'A dataset name can be at most 64 characters.';
+    if (!DATASET_NAME_PATTERN.test(name)) {
+        return 'A dataset name must be at least 2 characters, and use only a-z, 0-9, - and _, starting with a letter or a digit.';
+    }
+    return undefined;
+}
+/**
+ * Whether this run creates a project.
+ *
+ * `--create-project` decides it without asking. An organization with no projects has
+ * nothing to select, so creation is the only way forward there.
+ */
+export async function chooseProjectSource(options) {
+    const { flags, interactive, projects, organizationName } = options;
+    const named = flags.createProject?.trim();
+    if (!named && (flags.projectId || projects.length > 0)) {
+        if (flags.projectId || !interactive || flags.yes)
+            return { ok: true, value: { create: false } };
+        const source = await select({
+            message: `Use a project in ${organizationName}, or create one?`,
+            choices: [
+                { name: 'Use an existing project', value: 'existing' },
+                { name: 'Create a new project', value: 'new' },
+            ],
+        });
+        if (source === 'existing')
+            return { ok: true, value: { create: false } };
+    }
+    if (!named && !interactive) {
+        return {
+            ok: false,
+            error: {
+                message: `No projects found in ${organizationName}.`,
+                suggestions: ['Pass --create-project <name> to create one.'],
+            },
+        };
+    }
+    const displayName = named || (await promptForProjectName(organizationName));
+    if (!displayName) {
+        return { ok: false, error: { message: 'A new project needs a display name.' } };
+    }
+    const datasetName = await chooseDatasetName(flags, interactive && !flags.yes);
+    if (!datasetName.ok)
+        return datasetName;
+    return { ok: true, value: { create: true, displayName, datasetName: datasetName.value } };
+}
+async function promptForProjectName(organizationName) {
+    const answer = await input({
+        message: `Name your new project in ${organizationName}:`,
+        validate: (value) => value.trim().length > 0 || 'Enter a project name.',
+    });
+    return answer.trim();
+}
+/** The dataset the Blueprint will create, which no API call has made yet. */
+async function chooseDatasetName(flags, interactive) {
+    if (flags.datasetName) {
+        const problem = datasetNameError(flags.datasetName);
+        return problem
+            ? { ok: false, error: { message: `Dataset "${flags.datasetName}" is not valid. ${problem}` } }
+            : { ok: true, value: flags.datasetName };
+    }
+    if (!interactive)
+        return { ok: true, value: DEFAULT_DATASET_NAME };
+    const answer = await input({
+        message: 'Name the dataset this Blueprint will create:',
+        default: DEFAULT_DATASET_NAME,
+        validate: (value) => datasetNameError(value.trim()) ?? true,
+    });
+    return { ok: true, value: answer.trim() };
+}

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

@@ -0,0 +1,13 @@
+import type { BlueprinitFlags } from './types.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 declare function duplicateResourceNames(names: string[]): string[];
+export declare function confirmUnlessSkipped(flags: BlueprinitFlags, interactive: boolean, message: string): Promise<boolean>;
+/** The new Stack's name, which is also the hosted Studio slug. */
+export declare function promptForStackName(flags: BlueprinitFlags, interactive: boolean, defaultName: string): Promise<string>;
+/** The Blueprint-local Studio name, which is also its directory under `studios/`. */
+export declare function studioResourceName(flags: BlueprinitFlags): string;

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 {};