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

package/dist/actions/blueprinit/workspace.d.ts

@@ -0,0 +1,27 @@
+import { type DatasetAction } from './manifest.js';
+import { type StudioVersions } from './templates.js';
+export interface WorkspaceOptions {
+    dir: string;
+    projectId: string;
+    displayName: string;
+    datasetName: string;
+    /** Attach a dataset the project already has, or create one. Defaults to attach. */
+    datasetAction?: DatasetAction;
+    stackName: string;
+    /** Blueprint-local name for the attached project resource. */
+    projectName: string;
+    studioName: string;
+    studioSlug: string;
+    studioOrigin: string;
+    blueprintsVersion: string;
+}
+export interface ScaffoldOptions extends WorkspaceOptions {
+    /** Resolved at scaffold time, the way `sanity init` resolves its own Studio versions. */
+    studioVersions: StudioVersions;
+}
+export interface WorkspaceResult {
+    blueprintFilePath: string;
+    files: string[];
+}
+export declare function scaffoldWorkspace(options: ScaffoldOptions): WorkspaceResult;
+export declare function adoptWorkspace(options: WorkspaceOptions): WorkspaceResult;

package/dist/actions/blueprinit/workspace.js

@@ -0,0 +1,145 @@
+import { existsSync, mkdirSync, readFileSync, writeFileSync } from 'node:fs';
+import { dirname, join, posix } from 'node:path';
+import { renderBlueprint, STARTER_FUNCTION_NAME, studioSourcePath, } from './manifest.js';
+import { FUNCTION_SET_SLUG, functionPackageJson, renderStudioCliConfig, renderStudioConfig, STUDIO_POST_TYPE, STUDIO_SCHEMA_TYPES, STUDIO_TSCONFIG, studioPackageJson, } from './templates.js';
+const GITIGNORE_ENTRY = '# Sanity Blueprints\n.sanity/';
+const DEFAULT_GITIGNORE = `node_modules
+.env
+
+${GITIGNORE_ENTRY}
+`;
+export function scaffoldWorkspace(options) {
+    const { dir, studioName, studioVersions } = options;
+    assertTargetsAvailable(dir, [
+        studioSourcePath(studioName),
+        posix.join('functions', STARTER_FUNCTION_NAME),
+    ]);
+    const packageJson = preparePackageJson(options, ['studios/*', 'functions/*']);
+    const files = [];
+    const write = createWriter(dir, files);
+    const blueprintFilePath = write('sanity.blueprint.ts', renderBlueprint({
+        ...manifestOptions(options),
+        studioSrc: `./${studioSourcePath(studioName)}`,
+        withFunction: true,
+    }));
+    write(posix.join('studios', studioName, 'package.json'), formatJson(studioPackageJson(studioName, studioVersions)));
+    write(posix.join('studios', studioName, 'tsconfig.json'), formatJson(STUDIO_TSCONFIG));
+    write(posix.join('studios', studioName, 'sanity.config.ts'), renderStudioConfig(options));
+    write(posix.join('studios', studioName, 'sanity.cli.ts'), renderStudioCliConfig(options));
+    write(posix.join('studios', studioName, 'schemaTypes', 'index.ts'), STUDIO_SCHEMA_TYPES);
+    write(posix.join('studios', studioName, 'schemaTypes', 'post.ts'), STUDIO_POST_TYPE);
+    write(posix.join('studios', studioName, 'static', '.gitkeep'), '');
+    write(posix.join('functions', STARTER_FUNCTION_NAME, 'package.json'), formatJson(functionPackageJson(STARTER_FUNCTION_NAME)));
+    write(posix.join('functions', STARTER_FUNCTION_NAME, 'index.ts'), FUNCTION_SET_SLUG);
+    writePreparedRootFiles(dir, packageJson, files);
+    return { blueprintFilePath, files };
+}
+export function adoptWorkspace(options) {
+    const { dir } = options;
+    const packageJson = preparePackageJson(options, []);
+    const files = [];
+    const write = createWriter(dir, files);
+    const blueprintFilePath = write('sanity.blueprint.ts', renderBlueprint({ ...manifestOptions(options), studioSrc: '.', withFunction: false }));
+    writePreparedRootFiles(dir, packageJson, files);
+    return { blueprintFilePath, files };
+}
+function manifestOptions(options) {
+    return {
+        projectName: options.projectName,
+        displayName: options.displayName,
+        projectId: options.projectId,
+        datasetName: options.datasetName,
+        datasetAction: options.datasetAction ?? 'attach',
+        studioName: options.studioName,
+        studioSlug: options.studioSlug,
+        studioOrigin: options.studioOrigin,
+    };
+}
+function assertTargetsAvailable(dir, paths) {
+    const conflicts = paths.filter((path) => existsSync(join(dir, path)));
+    if (conflicts.length > 0) {
+        throw new Error(`Refusing to overwrite existing paths: ${conflicts.join(', ')}`);
+    }
+}
+function createWriter(dir, files) {
+    return (relativePath, content) => {
+        const filePath = join(dir, relativePath);
+        mkdirSync(dirname(filePath), { recursive: true });
+        writeFileSync(filePath, content);
+        files.push(relativePath);
+        return filePath;
+    };
+}
+function writePreparedRootFiles(dir, packageJson, files) {
+    if (writeGitignore(dir))
+        files.push('.gitignore');
+    writeFileSync(join(dir, 'package.json'), formatJson(packageJson));
+    files.push('package.json');
+}
+function writeGitignore(dir) {
+    const filePath = join(dir, '.gitignore');
+    if (!existsSync(filePath)) {
+        writeFileSync(filePath, DEFAULT_GITIGNORE);
+        return true;
+    }
+    const existing = readFileSync(filePath, 'utf8');
+    if (existing.split(/\r?\n/).some((line) => line.trim() === '.sanity/'))
+        return false;
+    writeFileSync(filePath, `${existing.trimEnd()}\n\n${GITIGNORE_ENTRY}\n`);
+    return true;
+}
+function preparePackageJson(options, requiredWorkspaces) {
+    const filePath = join(options.dir, 'package.json');
+    const parsed = existsSync(filePath)
+        ? JSON.parse(readFileSync(filePath, 'utf8'))
+        : {
+            name: options.stackName,
+            version: '0.1.0',
+            private: true,
+            type: 'module',
+        };
+    if (!parsed || typeof parsed !== 'object' || Array.isArray(parsed)) {
+        throw new Error('The existing package.json must contain a JSON object.');
+    }
+    const packageJson = parsed;
+    addWorkspaces(packageJson, requiredWorkspaces);
+    addBlueprintsDependency(packageJson, options.blueprintsVersion);
+    return packageJson;
+}
+function addWorkspaces(packageJson, required) {
+    if (required.length === 0)
+        return;
+    if (!packageJson.workspaces) {
+        packageJson.workspaces = required;
+        return;
+    }
+    if (Array.isArray(packageJson.workspaces)) {
+        packageJson.workspaces = [...new Set([...packageJson.workspaces, ...required])];
+        return;
+    }
+    // Neither falsy nor an array by now, so the only supported shape left is {packages: []}.
+    const workspaces = packageJson.workspaces;
+    if (typeof workspaces === 'object' && Array.isArray(workspaces.packages)) {
+        workspaces.packages = [...new Set([...workspaces.packages, ...required])];
+        return;
+    }
+    throw new Error('Cannot add generated packages to the existing package.json workspaces.');
+}
+function addBlueprintsDependency(packageJson, blueprintsVersion) {
+    const dependencies = recordOrEmpty(packageJson.dependencies);
+    const devDependencies = recordOrEmpty(packageJson.devDependencies);
+    if (dependencies['@sanity/blueprints'] || devDependencies['@sanity/blueprints'])
+        return;
+    packageJson.devDependencies = {
+        ...devDependencies,
+        '@sanity/blueprints': blueprintsVersion,
+    };
+}
+function recordOrEmpty(value) {
+    return value && typeof value === 'object' && !Array.isArray(value)
+        ? value
+        : {};
+}
+function formatJson(value) {
+    return `${JSON.stringify(value, null, 2)}\n`;
+}

package/dist/actions/blueprints/pre-deploy.js

@@ -73,6 +73,8 @@ async function preDeployStack(options) {
         };
     }
     spinner.stop().clear();
+    if (stack.changeCount === 0)
+        return { success: true };
     logger(styleText('dim', 'Stack deployment progress:'));
     logger('');
     const outcome = await waitForOperation({

package/dist/actions/blueprints/stacks.d.ts

@@ -48,6 +48,7 @@ type UpdateStackResponse = {
     error: null;
     stack: Stack & {
         operationId: string;
+        changeCount?: number;
     };
 } | {
     ok: false;

package/dist/actions/sanity/create-project.d.ts

@@ -0,0 +1,19 @@
+import type { Logger } from '../../utils/logger.js';
+import type { ActionResponse } from '../../utils/types.js';
+import { type Project } from './projects.js';
+export interface CreateProjectResult extends ActionResponse {
+    project?: Project;
+}
+/**
+ * Create a project in an organization.
+ *
+ * `createDefaultCorsOrigin` is false because the Blueprint declares the only origin the
+ * hosted Studio needs. The Blueprints project provider sends the same field for the same
+ * reason. No dataset comes back: this endpoint creates none, so the Blueprint creates it.
+ */
+export declare function createProject({ token, organizationId, displayName, logger, }: {
+    token: string;
+    organizationId: string;
+    displayName: string;
+    logger: Logger;
+}): Promise<CreateProjectResult>;

package/dist/actions/sanity/create-project.js

@@ -0,0 +1,32 @@
+import { createTracedFetch } from '../../utils/traced-fetch.js';
+import { projectsApiPath } from './projects.js';
+/**
+ * Create a project in an organization.
+ *
+ * `createDefaultCorsOrigin` is false because the Blueprint declares the only origin the
+ * hosted Studio needs. The Blueprints project provider sends the same field for the same
+ * reason. No dataset comes back: this endpoint creates none, so the Blueprint creates it.
+ */
+export async function createProject({ token, organizationId, displayName, logger, }) {
+    const fetchFn = createTracedFetch(logger);
+    try {
+        const response = await fetchFn(projectsApiPath, {
+            method: 'POST',
+            headers: { Authorization: `Bearer ${token}`, 'Content-Type': 'application/json' },
+            body: JSON.stringify({
+                displayName,
+                organizationId,
+                createDefaultCorsOrigin: false,
+                metadata: { integration: 'blueprints' },
+            }),
+        });
+        const body = await response.json();
+        if (!response.ok) {
+            return { ok: false, error: body?.error?.message || body?.message || `HTTP ${response.status}` };
+        }
+        return { ok: true, error: null, project: body };
+    }
+    catch (error) {
+        return { ok: false, error: error instanceof Error ? error.message : String(error) };
+    }
+}

package/dist/actions/sanity/datasets.d.ts

@@ -0,0 +1,15 @@
+import type { Logger } from '../../utils/logger.js';
+import type { ActionResponse } from '../../utils/types.js';
+export interface Dataset {
+    name: string;
+    aclMode: string;
+}
+interface ListDatasetsResponse extends ActionResponse {
+    datasets: Dataset[];
+}
+export declare function listDatasets({ token, projectId, logger, }: {
+    token: string;
+    projectId: string;
+    logger: Logger;
+}): Promise<ListDatasetsResponse>;
+export {};

package/dist/actions/sanity/datasets.js

@@ -0,0 +1,26 @@
+import { createTracedFetch } from '../../utils/traced-fetch.js';
+import { projectsApiPath } from './projects.js';
+export async function listDatasets({ token, projectId, logger, }) {
+    const fetchFn = createTracedFetch(logger);
+    const url = `${projectsApiPath}/${encodeURIComponent(projectId)}/datasets`;
+    const response = await fetchFn(url, {
+        method: 'GET',
+        headers: {
+            Authorization: `Bearer ${token}`,
+            'Content-Type': 'application/json',
+        },
+    });
+    const body = await response.json();
+    if (!response.ok) {
+        return {
+            ok: false,
+            error: body.error?.message ?? response.statusText,
+            datasets: [],
+        };
+    }
+    return {
+        ok: true,
+        error: null,
+        datasets: body,
+    };
+}

package/dist/commands/functions/test.d.ts

@@ -25,6 +25,7 @@ export default class TestCommand extends ResolvedCommand<typeof TestCommand> {
         'document-id-after': import("@oclif/core/interfaces").OptionFlag<string | undefined, import("@oclif/core/interfaces").CustomOptions>;
         'with-user-token': import("@oclif/core/interfaces").BooleanFlag<boolean>;
         'media-library-id': import("@oclif/core/interfaces").OptionFlag<string | undefined, import("@oclif/core/interfaces").CustomOptions>;
+        'no-wait': import("@oclif/core/interfaces").BooleanFlag<boolean>;
     };
     run(): Promise<Record<string, unknown> | undefined>;
 }

package/dist/commands/functions/test.js

@@ -146,6 +146,11 @@ Provide test data via --data (inline JSON), --file (JSON file), or --document-id
             exclusive: ['project-id', 'dataset'],
             required: false,
         }),
+        'no-wait': Flags.boolean({
+            description: 'Skip durable wait delays instead of sleeping',
+            default: false,
+            required: false,
+        }),
     };
     async run() {
         const { name } = this.args;

package/dist/commands/init.d.ts

@@ -0,0 +1,21 @@
+import { RuntimeCommand } from '../baseCommands.js';
+export default class InitCommand extends RuntimeCommand<typeof InitCommand> {
+    static hidden: boolean;
+    static summary: string;
+    static description: string;
+    static examples: string[];
+    static args: {
+        directory: import("@oclif/core/interfaces").Arg<string | undefined, Record<string, unknown>>;
+    };
+    static flags: {
+        llms: import("@oclif/core/interfaces").BooleanFlag<boolean>;
+        yes: import("@oclif/core/interfaces").BooleanFlag<boolean>;
+        'organization-id': import("@oclif/core/interfaces").OptionFlag<string | undefined, import("@oclif/core/interfaces").CustomOptions>;
+        'project-id': import("@oclif/core/interfaces").OptionFlag<string | undefined, import("@oclif/core/interfaces").CustomOptions>;
+        'create-project': import("@oclif/core/interfaces").OptionFlag<string | undefined, import("@oclif/core/interfaces").CustomOptions>;
+        dataset: import("@oclif/core/interfaces").OptionFlag<string | undefined, import("@oclif/core/interfaces").CustomOptions>;
+        'stack-name': import("@oclif/core/interfaces").OptionFlag<string | undefined, import("@oclif/core/interfaces").CustomOptions>;
+        'studio-name': import("@oclif/core/interfaces").OptionFlag<string | undefined, import("@oclif/core/interfaces").CustomOptions>;
+    };
+    run(): Promise<Record<string, unknown> | undefined>;
+}

package/dist/commands/init.js

@@ -0,0 +1,82 @@
+import { resolve } from 'node:path';
+import { Args, Flags } from '@oclif/core';
+import { llmsFlagConfig } from '@sanity-labs/oclif-plugin-skills-flag';
+import { RuntimeCommand } from '../baseCommands.js';
+import { blueprinitCore } from '../cores/blueprinit.js';
+import { playIntro } from '../utils/display/intro.js';
+import { Logger } from '../utils/logger.js';
+export default class InitCommand extends RuntimeCommand {
+    static hidden = true;
+    static summary = 'Experimental blueprints-first project init';
+    static description = `Scaffolds a Blueprint, Studio, and starter function around a Sanity project.
+
+Use a project you already have, or create one with --create-project. A new project has no
+datasets, so the Blueprint creates the dataset rather than attaching it.
+
+Pass a directory to scaffold into it. Without one, an interactive run asks where the files go.
+
+This hidden command is an experiment; its interface and generated files are not stable.`;
+    static examples = [
+        '<%= config.bin %> <%= command.id %>',
+        '<%= config.bin %> <%= command.id %> ./my-workspace',
+        '<%= config.bin %> <%= command.id %> --yes',
+        '<%= config.bin %> <%= command.id %> --project-id <id> --dataset <name> --yes',
+        '<%= config.bin %> <%= command.id %> --create-project "My Shop" --yes',
+    ];
+    static args = {
+        directory: Args.string({
+            description: 'Directory to initialize. Interactive runs are asked for one instead.',
+            required: false,
+        }),
+    };
+    static flags = {
+        llms: Flags.boolean(llmsFlagConfig),
+        yes: Flags.boolean({
+            char: 'y',
+            description: 'Skip confirmation prompts',
+            default: false,
+        }),
+        'organization-id': Flags.string({
+            description: 'Organization to use when the account has several',
+            aliases: ['organization', 'organizationId', 'org'],
+        }),
+        'project-id': Flags.string({
+            description: 'Project to use when the organization has several',
+            aliases: ['project', 'projectId'],
+        }),
+        'create-project': Flags.string({
+            description: 'Create a project with this display name instead of using an existing one',
+            aliases: ['createProject', 'new-project'],
+            exclusive: ['project-id'],
+        }),
+        dataset: Flags.string({
+            description: 'Dataset to attach, or to create alongside a new project',
+        }),
+        'stack-name': Flags.string({
+            description: 'Name for the new organization-scoped Stack, and the hosted Studio slug',
+        }),
+        'studio-name': Flags.string({
+            description: 'Blueprint-local name for the Studio resource and its directory',
+        }),
+    };
+    async run() {
+        await playIntro({ json: this.jsonEnabled() });
+        const result = await blueprinitCore({
+            bin: this.config.bin,
+            dir: this.args.directory ? resolve(this.args.directory) : undefined,
+            log: Logger(this.log.bind(this), this.flags),
+            flags: {
+                yes: this.flags.yes,
+                organizationId: this.flags['organization-id'],
+                projectId: this.flags['project-id'],
+                createProject: this.flags['create-project'],
+                datasetName: this.flags.dataset,
+                stackName: this.flags['stack-name'],
+                studioName: this.flags['studio-name'],
+            },
+        });
+        if (!result.success)
+            this.coreError(result);
+        return result.json;
+    }
+}

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

@@ -0,0 +1,6 @@
+import type { DetectedStudio } from '../../actions/blueprinit/studio.js';
+import type { CoreResult } from '../index.js';
+import type { BlueprinitFlowOptions } from './types.js';
+export declare function adoptFlow(options: BlueprinitFlowOptions & {
+    studio: DetectedStudio;
+}): Promise<CoreResult>;

package/dist/cores/blueprinit/adopt.js

@@ -0,0 +1,137 @@
+import { existsSync } from 'node:fs';
+import { join } from 'node:path';
+import { corsResourceName, projectBaseName, projectResourceName, } from '../../actions/blueprinit/manifest.js';
+import { getLatestNpmRange } from '../../actions/blueprinit/versions.js';
+import { adoptWorkspace } from '../../actions/blueprinit/workspace.js';
+import { listDatasets } from '../../actions/sanity/datasets.js';
+import { groupProjectsByOrganization } from '../../actions/sanity/projects.js';
+import { check } from '../../utils/display/presenters.js';
+import { isInteractive } from '../../utils/interactive.js';
+import { styleText } from '../../utils/style-text.js';
+import { alignSteps, createStackAndFinish } from './finish.js';
+import { chooseNames } from './naming.js';
+import { fileLines, printBlueprintPreview } from './preview.js';
+import { confirmUnlessSkipped, studioResourceName } from './prompts.js';
+import { coreFailure } from './results.js';
+import { findProject } from './selection.js';
+export async function adoptFlow(options) {
+    const { bin, dir, flags, log, studio, token } = options;
+    if (flags.projectId && studio.projectId && flags.projectId !== studio.projectId) {
+        return { success: false, error: `The Studio uses project "${studio.projectId}".` };
+    }
+    if (flags.datasetName && studio.dataset && flags.datasetName !== studio.dataset) {
+        return { success: false, error: `The Studio uses dataset "${studio.dataset}".` };
+    }
+    const projectId = studio.projectId ?? flags.projectId;
+    const datasetName = studio.dataset ?? flags.datasetName;
+    if (!projectId || !datasetName) {
+        return {
+            success: false,
+            error: `Found ${studio.configFile}, but could not read a projectId and dataset from it.`,
+            suggestions: ['Use literal values in the Studio config or pass --project-id and --dataset.'],
+        };
+    }
+    log(check(`Studio detected (${studio.configFile})`));
+    const grouped = await groupProjectsByOrganization({ token, logger: log });
+    if (!grouped.ok) {
+        return { success: false, error: `Could not list organizations: ${grouped.error}` };
+    }
+    const match = findProject(grouped.organizations, projectId);
+    if (!match) {
+        return {
+            success: false,
+            error: `Project "${projectId}" from ${studio.configFile} was not found in your account.`,
+        };
+    }
+    if (flags.organizationId && flags.organizationId !== match.organization.id) {
+        return {
+            success: false,
+            error: `Project "${studio.projectId}" belongs to organization "${match.organization.id}".`,
+        };
+    }
+    const datasets = await listDatasets({ token, projectId: match.project.id, logger: log });
+    if (!datasets.ok) {
+        return { success: false, error: `Could not list datasets: ${datasets.error}` };
+    }
+    if (!datasets.datasets.some(({ name }) => name === datasetName)) {
+        return {
+            success: false,
+            error: `Dataset "${datasetName}" was not found in project ${match.project.displayName}.`,
+        };
+    }
+    log(check(`Matches project ${match.project.displayName} (${match.project.id}), dataset ${datasetName}`));
+    log('');
+    const baseName = projectBaseName(match.project.displayName, match.project.id);
+    const projectName = projectResourceName(baseName);
+    const studioName = studioResourceName(flags);
+    const names = await chooseNames({
+        flags,
+        log,
+        token,
+        organizationId: match.organization.id,
+        baseName,
+        datasetName,
+        resourceNames: [projectName, datasetName, corsResourceName(studioName), studioName],
+    });
+    if (!names.ok)
+        return coreFailure(names.error);
+    const { stackName, studioOrigin } = names.value;
+    // Started before the preview so the lookup overlaps the time the reader spends on it.
+    const blueprintsVersion = getLatestNpmRange('@sanity/blueprints', log);
+    const marker = (file) => (existsSync(join(dir, file)) ? '~' : '+');
+    const { attaches, creates } = printBlueprintPreview({
+        log,
+        organizationName: match.organization.name,
+        projectId: match.project.id,
+        projectName: match.project.displayName,
+        datasetName,
+        datasetAction: 'attach',
+        studioName,
+        studioOrigin,
+        studioSource: '.',
+        stackName,
+    });
+    log(styleText('bold', 'Changes:'));
+    for (const line of fileLines([
+        ['+', 'sanity.blueprint.ts', "attach project + dataset; add CORS and Studio at '.'"],
+        ['+', '.sanity/blueprint.config.json', `org scope, stack ${stackName}`],
+        [marker('.gitignore'), '.gitignore'],
+        [marker('package.json'), 'package.json'],
+    ])) {
+        log(line);
+    }
+    log('');
+    const confirmed = await confirmUnlessSkipped(flags, isInteractive, 'Adopt this Studio into the Blueprint?');
+    if (!confirmed)
+        return { success: false, error: 'Initialization cancelled.' };
+    const adoption = adoptWorkspace({
+        dir,
+        projectId: match.project.id,
+        displayName: match.project.displayName,
+        datasetName,
+        stackName,
+        projectName,
+        studioName,
+        studioSlug: stackName,
+        studioOrigin,
+        blueprintsVersion: await blueprintsVersion,
+    });
+    return await createStackAndFinish({
+        ...options,
+        organizationId: match.organization.id,
+        projectId: match.project.id,
+        datasetName,
+        stackName,
+        blueprintFilePath: adoption.blueprintFilePath,
+        files: adoption.files,
+        nextSteps: [
+            ...alignSteps([
+                [`npx ${bin} blueprints plan`, `preview the ${attaches} attaches and ${creates} creates`],
+                [`npx ${bin} blueprints deploy`, 'attach and create them'],
+                [`npx ${bin} blueprints info`, 'review what the Stack owns'],
+            ]),
+            '',
+            `Your Studio is hosted at ${studioOrigin} after deploy.`,
+        ],
+    });
+}

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

@@ -0,0 +1,26 @@
+import { styleText } from '../../utils/style-text.js';
+type TextStyle = Parameters<typeof styleText>[0];
+/**
+ * One cell in an aligned row.
+ *
+ * `text` is the raw string. It sets the column width and is styled only after padding,
+ * so a colour code can never widen a column.
+ */
+export interface Cell {
+    text: string;
+    style?: TextStyle;
+    /**
+     * Spaces between this column and the next, beyond the padding. Defaults to 1.
+     *
+     * A gap is a property of the column, so one row may set it for every row.
+     */
+    gap?: number;
+}
+/**
+ * Render rows as columns of one shared width, then style each cell.
+ *
+ * The last cell in a row is never padded, so a row that stops early prints no trailing
+ * space. Pass every row that should line up in one call.
+ */
+export declare function renderRows(rows: Cell[][]): string[];
+export {};

package/dist/cores/blueprinit/columns.js

@@ -0,0 +1,27 @@
+import { styleText } from '../../utils/style-text.js';
+const INDENT = '  ';
+/**
+ * Render rows as columns of one shared width, then style each cell.
+ *
+ * The last cell in a row is never padded, so a row that stops early prints no trailing
+ * space. Pass every row that should line up in one call.
+ */
+export function renderRows(rows) {
+    const widths = [];
+    const gaps = [];
+    for (const row of rows) {
+        row.forEach((cell, index) => {
+            widths[index] = Math.max(widths[index] ?? 0, cell.text.length);
+            gaps[index] = Math.max(gaps[index] ?? 1, cell.gap ?? 1);
+        });
+    }
+    return rows.map((row) => {
+        const cells = row.map((cell, index) => {
+            const styled = cell.style ? styleText(cell.style, cell.text) : cell.text;
+            if (index === row.length - 1)
+                return styled;
+            return styled + ' '.repeat(widths[index] - cell.text.length + gaps[index]);
+        });
+        return INDENT + cells.join('');
+    });
+}

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

@@ -0,0 +1,15 @@
+import type { CoreResult } from '../index.js';
+import type { BlueprinitFlowOptions } from './types.js';
+interface FinishOptions extends BlueprinitFlowOptions {
+    organizationId: string;
+    projectId: string;
+    datasetName: string;
+    stackName: string;
+    blueprintFilePath: string;
+    files: string[];
+    nextSteps: string[];
+}
+export declare function createStackAndFinish(options: FinishOptions): Promise<CoreResult>;
+/** A command to run next, and what it does. */
+export declare function alignSteps(steps: Array<[command: string, description?: string]>): string[];
+export {};