@sanity/runtime-cli 17.6.0-blueprinit.g77b7a64 → 17.6.1

package/dist/actions/blueprinit/workspace.js

@@ -1,143 +0,0 @@
-import { existsSync, mkdirSync, readFileSync, writeFileSync } from 'node:fs';
-import { dirname, join, posix } from 'node:path';
-import { renderBlueprint, STARTER_FUNCTION_NAME } from './manifest.js';
-import { FUNCTION_SET_SLUG, functionPackageJson, renderStudioConfig, STUDIO_POST_TYPE, STUDIO_SCHEMA_TYPES, 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 } = options;
-    assertTargetsAvailable(dir, [
-        posix.join('studios', 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: `./studios/${studioName}`,
-        withFunction: true,
-    }));
-    write(posix.join('studios', studioName, 'package.json'), formatJson(studioPackageJson(studioName)));
-    write(posix.join('studios', studioName, 'sanity.config.ts'), renderStudioConfig(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.stackName,
-        displayName: options.displayName,
-        projectId: options.projectId,
-        datasetName: options.datasetName,
-        studioName: options.studioName,
-        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;
-    }
-    if (!packageJson.workspaces || typeof packageJson.workspaces !== 'object') {
-        throw new Error('Cannot add generated packages to the existing package.json workspaces.');
-    }
-    const workspaces = packageJson.workspaces;
-    if (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/sanity/datasets.d.ts

@@ -1,15 +0,0 @@
-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

@@ -1,26 +0,0 @@
-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/init.d.ts

@@ -1,17 +0,0 @@
-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 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>;
-        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

@@ -1,59 +0,0 @@
-import { 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 { 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 an existing Sanity project.
-
-This hidden command is an experiment; its interface and generated files are not stable.`;
-    static examples = [
-        '<%= config.bin %> <%= command.id %>',
-        '<%= config.bin %> <%= command.id %> --yes',
-        '<%= config.bin %> <%= command.id %> --project-id <id> --dataset <name> --yes',
-    ];
-    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'],
-        }),
-        dataset: Flags.string({
-            description: 'Dataset to attach',
-        }),
-        'stack-name': Flags.string({
-            description: 'Name for the new organization-scoped Stack',
-        }),
-        'studio-name': Flags.string({
-            description: 'Name and hosted slug for the Studio resource',
-        }),
-    };
-    async run() {
-        const result = await blueprinitCore({
-            bin: this.config.bin,
-            log: Logger(this.log.bind(this), this.flags),
-            flags: {
-                yes: this.flags.yes,
-                organizationId: this.flags['organization-id'],
-                projectId: this.flags['project-id'],
-                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

@@ -1,6 +0,0 @@
-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

@@ -1,119 +0,0 @@
-import { existsSync } from 'node:fs';
-import { join } from 'node:path';
-import { env } from 'node:process';
-import { hostedStudioOrigin, slugify } from '../../actions/blueprinit/manifest.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 { getLatestNpmVersion } from '../../utils/external/npmjs.js';
-import { isInteractive } from '../../utils/interactive.js';
-import { createStackAndFinish } from './finish.js';
-import { printBlueprintPreview } from './preview.js';
-import { confirmUnlessSkipped, promptForStudioName, resourceNamesCollide } from './prompts.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 studioName = await promptForStudioName(flags, isInteractive);
-    const stackName = flags.stackName
-        ? slugify(flags.stackName) || match.project.id
-        : slugify(match.project.displayName) || match.project.id;
-    if (resourceNamesCollide(stackName, studioName)) {
-        return {
-            success: false,
-            error: `Stack and Studio names both resolve to "${stackName}". Blueprint resource names must be unique.`,
-            suggestions: ['Pass --stack-name or --studio-name with a different value.'],
-        };
-    }
-    const studioOrigin = hostedStudioOrigin(studioName, env.SANITY_INTERNAL_ENV);
-    const marker = (file) => (existsSync(join(dir, file)) ? '~' : '+');
-    printBlueprintPreview({
-        log,
-        organizationName: match.organization.name,
-        projectId: match.project.id,
-        projectName: match.project.displayName,
-        datasetName,
-        studioName,
-        studioOrigin,
-        studioSource: '.',
-        stackName,
-    });
-    log('Changes:');
-    log("  + sanity.blueprint.ts             attach project + dataset; add CORS and Studio at '.'");
-    log(`  + .sanity/blueprint.config.json   org scope, stack ${stackName}`);
-    log(`  ${marker('.gitignore')} .gitignore`);
-    log(`  ${marker('package.json')} package.json`);
-    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,
-        studioName,
-        studioOrigin,
-        blueprintsVersion: await getLatestNpmVersion('@sanity/blueprints', log),
-    });
-    return await createStackAndFinish({
-        ...options,
-        organizationId: match.organization.id,
-        projectId: match.project.id,
-        datasetName,
-        stackName,
-        blueprintFilePath: adoption.blueprintFilePath,
-        files: adoption.files,
-        nextSteps: [
-            `  npx ${bin} blueprints plan`,
-            `  npx ${bin} blueprints deploy`,
-            `  npx ${bin} blueprints info`,
-        ],
-    });
-}

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

@@ -1,14 +0,0 @@
-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>;
-export declare function alignSteps(steps: Array<[command: string, description?: string]>): string[];
-export {};

package/dist/cores/blueprinit/finish.js

@@ -1,64 +0,0 @@
-import { writeConfigFile } from '../../actions/blueprints/config.js';
-import { createEmptyStack } from '../../actions/blueprints/stacks.js';
-import { check } from '../../utils/display/presenters.js';
-export async function createStackAndFinish(options) {
-    let stack;
-    try {
-        stack = await createEmptyStack({
-            token: options.token,
-            scopeType: 'organization',
-            scopeId: options.organizationId,
-            name: options.stackName,
-            logger: options.log,
-        });
-    }
-    catch (error) {
-        const message = error instanceof Error ? error.message : String(error);
-        return {
-            success: false,
-            error: `Local files were written, but Stack creation failed: ${message}`,
-            suggestions: [
-                'Resolve the Stack error, then finish setup with:',
-                `npx ${options.bin} blueprints init --organization-id ${options.organizationId} --stack-name ${options.stackName}`,
-            ],
-        };
-    }
-    try {
-        writeConfigFile(options.blueprintFilePath, {
-            organizationId: options.organizationId,
-            stackId: stack.id,
-        });
-    }
-    catch (error) {
-        const message = error instanceof Error ? error.message : String(error);
-        return {
-            success: false,
-            error: `Stack ${stack.id} was created, but the local Blueprint config could not be written: ${message}`,
-            suggestions: [
-                'Finish setup with:',
-                `npx ${options.bin} blueprints init --organization-id ${options.organizationId} --stack-id ${stack.id}`,
-            ],
-        };
-    }
-    options.log(check(`Stack ${stack.name} created (org scope)`));
-    options.log('The Stack is empty; Blueprint resources have not been deployed.');
-    options.log('');
-    options.log('Next steps:');
-    for (const step of options.nextSteps)
-        options.log(step);
-    return {
-        success: true,
-        json: {
-            organizationId: options.organizationId,
-            projectId: options.projectId,
-            dataset: options.datasetName,
-            stackId: stack.id,
-            stackName: stack.name,
-            files: [...options.files, '.sanity/blueprint.config.json'],
-        },
-    };
-}
-export function alignSteps(steps) {
-    const width = Math.max(...steps.map(([command]) => command.length));
-    return steps.map(([command, description]) => description ? `  ${command.padEnd(width + 2)}${description}` : `  ${command}`);
-}

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

@@ -1,3 +0,0 @@
-import type { CoreResult } from '../index.js';
-import type { BlueprinitFlowOptions } from './types.js';
-export declare function freshFlow(options: BlueprinitFlowOptions): Promise<CoreResult>;

package/dist/cores/blueprinit/fresh.js

@@ -1,120 +0,0 @@
-import { env } from 'node:process';
-import { hostedStudioOrigin, STARTER_FUNCTION_NAME, slugify, } from '../../actions/blueprinit/manifest.js';
-import { scaffoldWorkspace } 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 { getLatestNpmVersion } from '../../utils/external/npmjs.js';
-import { isInteractive } from '../../utils/interactive.js';
-import { alignSteps, createStackAndFinish } from './finish.js';
-import { printBlueprintPreview } from './preview.js';
-import { confirmUnlessSkipped, promptForStudioName, resourceNamesCollide } from './prompts.js';
-import { chooseDataset, chooseOrganization, chooseProject } from './selection.js';
-export async function freshFlow(options) {
-    const { bin, dir, flags, log, token } = options;
-    const grouped = await groupProjectsByOrganization({ token, logger: log });
-    if (!grouped.ok) {
-        return { success: false, error: `Could not list organizations: ${grouped.error}` };
-    }
-    const organizationResult = await chooseOrganization(grouped.organizations, flags.organizationId, isInteractive);
-    if (!organizationResult.ok) {
-        return {
-            success: false,
-            error: organizationResult.error.message,
-            suggestions: organizationResult.error.suggestions,
-        };
-    }
-    const { organization, projects = [] } = organizationResult.value;
-    const projectResult = await chooseProject(projects, flags.projectId, organization.name, isInteractive);
-    if (!projectResult.ok) {
-        return {
-            success: false,
-            error: projectResult.error.message,
-            suggestions: projectResult.error.suggestions,
-        };
-    }
-    const project = projectResult.value;
-    const datasets = await listDatasets({ token, projectId: project.id, logger: log });
-    if (!datasets.ok) {
-        return { success: false, error: `Could not list datasets: ${datasets.error}` };
-    }
-    const datasetResult = await chooseDataset(datasets.datasets, flags.datasetName, project.displayName, isInteractive);
-    if (!datasetResult.ok) {
-        return {
-            success: false,
-            error: datasetResult.error.message,
-            suggestions: datasetResult.error.suggestions,
-        };
-    }
-    const dataset = datasetResult.value;
-    log(check(`Org: ${organization.name} (${organization.id})`));
-    log(check(`Project: ${project.displayName} (${project.id}), dataset: ${dataset.name}`));
-    log('');
-    const stackName = flags.stackName
-        ? slugify(flags.stackName) || project.id
-        : slugify(project.displayName) || project.id;
-    const studioName = await promptForStudioName(flags, isInteractive);
-    if (resourceNamesCollide(stackName, studioName)) {
-        return {
-            success: false,
-            error: `Stack and Studio names both resolve to "${stackName}". Blueprint resource names must be unique.`,
-            suggestions: ['Pass --stack-name or --studio-name with a different value.'],
-        };
-    }
-    const studioOrigin = hostedStudioOrigin(studioName, env.SANITY_INTERNAL_ENV);
-    printBlueprintPreview({
-        log,
-        organizationName: organization.name,
-        projectId: project.id,
-        projectName: project.displayName,
-        datasetName: dataset.name,
-        studioName,
-        studioOrigin,
-        studioSource: `studios/${studioName}`,
-        stackName,
-        functionName: STARTER_FUNCTION_NAME,
-    });
-    log('Files to write:');
-    log('  + sanity.blueprint.ts             project + dataset (attached), CORS, studio, function');
-    const studioDirectory = `studios/${studioName}/`;
-    log(`  + ${studioDirectory.padEnd(Math.max(32, studioDirectory.length + 2))}Studio with a "post" type`);
-    log(`  + ${`functions/${STARTER_FUNCTION_NAME}/`.padEnd(32)}sets a post slug from its title`);
-    log(`  + .sanity/blueprint.config.json   org scope, stack ${stackName}`);
-    log('  + .gitignore');
-    log('  + package.json');
-    log('');
-    const confirmed = await confirmUnlessSkipped(flags, isInteractive, `Create this Blueprint workspace for "${project.displayName}"?`);
-    if (!confirmed)
-        return { success: false, error: 'Initialization cancelled.' };
-    const scaffold = scaffoldWorkspace({
-        dir,
-        projectId: project.id,
-        displayName: project.displayName,
-        datasetName: dataset.name,
-        stackName,
-        studioName,
-        studioOrigin,
-        blueprintsVersion: await getLatestNpmVersion('@sanity/blueprints', log),
-    });
-    return await createStackAndFinish({
-        ...options,
-        organizationId: organization.id,
-        projectId: project.id,
-        datasetName: dataset.name,
-        stackName,
-        blueprintFilePath: scaffold.blueprintFilePath,
-        files: scaffold.files,
-        nextSteps: [
-            ...alignSteps([
-                ['npm install'],
-                [`npm run dev -w studios/${studioName}`, 'open the Studio and add a post'],
-                [`npx ${bin} blueprints plan`, 'preview the deployment'],
-                [`npx ${bin} blueprints deploy`, 'deploy the resources'],
-            ]),
-            '',
-            'Test the function on that post:',
-            `  npx ${bin} functions test ${STARTER_FUNCTION_NAME} --document-id <id>` +
-                ` --project-id ${project.id} --dataset ${dataset.name} --with-user-token`,
-        ],
-    });
-}

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

@@ -1,15 +0,0 @@
-import type { Logger } from '../../utils/logger.js';
-interface BlueprintPreviewOptions {
-    log: Logger;
-    organizationName: string;
-    projectId: string;
-    projectName: string;
-    datasetName: string;
-    studioName: string;
-    studioOrigin: string;
-    studioSource: string;
-    stackName: string;
-    functionName?: string;
-}
-export declare function printBlueprintPreview(options: BlueprintPreviewOptions): void;
-export {};

package/dist/cores/blueprinit/preview.js

@@ -1,14 +0,0 @@
-export function printBlueprintPreview(options) {
-    options.log('Blueprint plan:');
-    options.log(`  attach  Project ${options.projectName} (${options.projectId}) on deploy; retain on Stack removal`);
-    options.log(`  attach  Dataset ${options.datasetName} on deploy; retain on Stack removal`);
-    options.log(`  create  CORS Origin ${options.studioName}-cors for ${options.studioOrigin} on deploy`);
-    options.log(`  create  Studio ${options.studioName} from ${options.studioSource} at ${options.studioOrigin} on deploy`);
-    if (options.functionName) {
-        options.log(`  create  Function ${options.functionName} on deploy`);
-    }
-    options.log('');
-    options.log('Remote action now:');
-    options.log(`  create  Stack ${options.stackName} in ${options.organizationName} (empty, organization scope)`);
-    options.log('');
-}

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

@@ -1,5 +0,0 @@
-import type { BlueprinitFlags } from './types.js';
-export declare const DEFAULT_STUDIO_NAME = "studio";
-export declare function resourceNamesCollide(stackName: string, studioName: string): boolean;
-export declare function confirmUnlessSkipped(flags: BlueprinitFlags, interactive: boolean, message: string): Promise<boolean>;
-export declare function promptForStudioName(flags: BlueprinitFlags, interactive: boolean): Promise<string>;

package/dist/cores/blueprinit/prompts.js

@@ -1,22 +0,0 @@
-import { confirm, input } from '@inquirer/prompts';
-import { slugify } from '../../actions/blueprinit/manifest.js';
-export const DEFAULT_STUDIO_NAME = 'studio';
-export function resourceNamesCollide(stackName, studioName) {
-    return stackName === studioName;
-}
-export async function confirmUnlessSkipped(flags, interactive, message) {
-    if (flags.yes || !interactive)
-        return true;
-    return await confirm({ message, default: true });
-}
-export async function promptForStudioName(flags, interactive) {
-    if (flags.studioName)
-        return slugify(flags.studioName) || DEFAULT_STUDIO_NAME;
-    if (flags.yes || !interactive)
-        return DEFAULT_STUDIO_NAME;
-    const answer = await input({
-        message: 'Name your Studio and hosted slug?',
-        default: DEFAULT_STUDIO_NAME,
-    });
-    return slugify(answer) || DEFAULT_STUDIO_NAME;
-}