@sanity/runtime-cli 17.9.0-blueprinit.g14aaebd → 17.10.0-next.g5e0bba6

package/dist/cores/blueprinit/selection.js

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

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

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

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

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

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

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

package/dist/cores/blueprinit.d.ts

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

@@ -1,64 +0,0 @@
-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/utils/display/intro.d.ts

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

@@ -1,63 +0,0 @@
-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();
-    }
-}

package/skills/init.md

@@ -1,199 +0,0 @@
-# init
-
-Use `init` to scaffold a Blueprint around an existing Sanity project. The command is
-experimental, hidden from root help, and available from the `blueprinit` npm dist-tag.
-
-Use it for demos and evaluation, not as a stable project initializer. Its flags, generated files,
-and resource model may change.
-
-## Know what it does
-
-`init` uses an existing Sanity organization. It uses a project that exists, or creates one with
-`--create-project`. It writes local Blueprint files, then creates an empty organization-scoped
-Stack. The generated Blueprint attaches the project and declares resources for a later deployment.
-
-The dataset works one of two ways:
-
-- **Existing project:** the user picks one of its datasets, and the Blueprint attaches it.
-- **New project:** a new project has no datasets, so the Blueprint creates one. Its name comes from
-  `--dataset` and defaults to `production`. It does not exist until `blueprints deploy` runs.
-
-It does not create an organization. It does not deploy the attached resources, CORS origin, Studio,
-or Function. Those changes happen only if `blueprints deploy` is run later.
-
-## Inspect the target directory
-
-Pass the directory as an argument, or run the command from the directory that should contain the
-Blueprint. Without an argument an interactive run asks where the files go; an unattended run keeps
-the current directory.
-
-Before running:
-
-1. Check the working tree and existing files. Do not discard unrelated user changes.
-2. Look for a root `sanity.blueprint.*` file. If one exists, use the existing Blueprint instead of
-   initializing again.
-3. Look for a root `sanity.config.*` file. Its presence selects the Studio adoption flow.
-4. Confirm the user asked to initialize this directory. The command writes files and creates a
-   remote Stack.
-5. Confirm the user is signed in. If needed, have them run:
-
-```sh
-npx sanity login
-```
-
-The account must have at least one organization. A run against an existing project also needs one
-project in the selected organization and one dataset in that project. A run with `--create-project`
-needs neither.
-
-Interactive runs show the Blueprint resources, hosted Studio URL, local changes, and remote actions
-before the confirmation prompt. Everything the Blueprint declares stays pending until a later
-deployment.
-
-A run that creates a project makes two remote changes rather than one: the project, then the Stack.
-Both happen after the confirmation, so a cancelled run creates nothing. The project is created
-before any file is written, because the generated Studio config needs its ID.
-
-## Choose the flow
-
-- **Existing Blueprint with a configured Stack:** Exit without changes and use
-  `blueprints config --edit` or `blueprints doctor`.
-- **Existing Blueprint without a configured Stack:** Finish setup with `blueprints init`; it can
-  connect the existing manifest without rewriting it.
-- **Root Studio config:** Adopt the Studio in place. Read literal `projectId` and `dataset` strings
-  from `sanity.config.*`, falling back to `sanity.cli.*`. Do not move the Studio.
-- **Fresh workspace:** Create a Blueprint, an npm-workspace Studio, and a starter `set-slug`
-  document function.
-
-Do not rewrite a Studio config merely to make adoption work unless the user asks. Dynamic
-`projectId` or `dataset` values built from environment variables or imports cannot be detected.
-
-For an existing Blueprint, inspect it with:
-
-```sh
-npx @sanity/runtime-cli@blueprinit blueprints doctor
-```
-
-## Run unattended
-
-When the organization and project IDs are known, run this from the target directory:
-
-```sh
-npx @sanity/runtime-cli@blueprinit init --yes \
-  --organization-id <organization-id> \
-  --project-id <project-id> \
-  --dataset <dataset-name>
-```
-
-To create the project instead, replace `--project-id` with `--create-project`:
-
-```sh
-npx @sanity/runtime-cli@blueprinit init --yes \
-  --organization-id <organization-id> \
-  --create-project "<project display name>" \
-  --dataset <dataset-name>
-```
-
-`--create-project` and `--project-id` cannot both be passed. With `--create-project`, `--dataset`
-names a dataset to create and defaults to `production`.
-
-Replace all placeholders with real values. The project must belong to the organization, and the
-dataset must belong to the project. Do not guess any value.
-
-`--yes` skips confirmation. Without explicit values, an unattended run stops when the account has
-several organizations, projects, or datasets. Ask the user for the missing value or have them run
-the command interactively.
-
-Use `--stack-name <name>` and `--studio-name <name>` when those generated names need to be stable.
-The command normalizes both names to lowercase kebab case.
-
-The Stack name defaults to `<project>-<dataset>` and is also the hosted Studio slug, so it must be
-available across every Sanity organization. No API reports whether a slug is free, so a taken one
-fails during `blueprints deploy`.
-
-The Studio name is a Blueprint-local resource name and its directory under `studios/`. It defaults
-to `studio`. Every other generated name carries its resource type, so the defaults cannot collide.
-A dataset named `studio`, or `--studio-name production` against a `production` dataset, does
-collide; the command names the repeated value and writes nothing.
-
-When `SANITY_INTERNAL_ENV=staging`, the generated Studio URL and CORS origin use
-`https://<stack-name>.studio.sanity.work`. Other environments use
-`https://<stack-name>.sanity.studio`.
-
-For interactive organization, project, dataset, Stack-name, and confirmation prompts, have the
-user run:
-
-```sh
-npx @sanity/runtime-cli@blueprinit init
-```
-
-When the project has several datasets, the interactive command prompts for one and lists
-`production` first. Report the selected dataset from the command output.
-
-## Review the result
-
-A successful fresh run creates or updates:
-
-```text
-.
-├── .sanity/blueprint.config.json
-├── sanity.blueprint.ts
-├── package.json
-├── functions/
-│   └── set-slug/
-└── studios/
-    └── studio/
-```
-
-The command also creates or updates `.gitignore`. It preserves existing package metadata and adds
-the required npm workspaces and `@sanity/blueprints` dependency.
-
-The generated Studio matches `sanity init`: the same `sanity`, `@sanity/vision`, `react`,
-`react-dom`, `styled-components`, `@types/react`, and `typescript` versions, the same
-`tsconfig.json`, and `visionTool()` beside `structureTool()`. `sanity` and `@sanity/vision` are
-resolved from the registry at scaffold time, so no version is written into this repository.
-The Studio has no `deploy` script, because the Blueprint deploys it.
-
-An adopted Studio stays at the repository root. The command adds the Blueprint, Blueprint config,
-dependency, and `.gitignore` entry, but does not generate the starter Function.
-
-After the command exits:
-
-1. Confirm the output names the expected organization, project, and dataset.
-2. Confirm `.sanity/blueprint.config.json` exists. Its presence means Stack creation completed.
-3. Review `sanity.blueprint.ts`, including the Studio slug and credentialed CORS origin, plus
-   `package.json`, `.gitignore`, and the working-tree diff.
-4. Report the Stack ID and every created or modified path.
-
-Do not deploy as part of initialization unless the user separately asks for deployment. To continue
-after reviewing the scaffold, install dependencies and preview the deployment:
-
-```sh
-npm install
-npx @sanity/runtime-cli@blueprinit blueprints plan
-```
-
-Treat dependency installation and planning as separate follow-up actions when they were not part of
-the user's request.
-
-## Handle failures
-
-- **`No Sanity session found.`** Stop and ask the user to run `npx sanity login`. Authentication
-  fails before files are written.
-- **Multiple organizations or projects found.** Rerun with the matching `--organization-id` and
-  `--project-id`. Selection fails before files are written.
-- **No datasets found.** Ask the user to choose a project with a dataset, or to create a project
-  with `--create-project`, which makes the Blueprint create the dataset too.
-- **No projects found in an organization.** In an unattended run, pass `--create-project <name>`.
-- **Dataset name is not valid.** The projects API allows 2 to 64 characters from `a-z`, `0-9`, `-`,
-  and `_`, starting with a letter or a digit. Report the rule and ask for another name. Do not
-  rewrite the name the user gave.
-- **Could not create project.** Nothing was written. Report the API message. A quota error needs a
-  plan change or another organization.
-- **Could not read `projectId` and `dataset`.** The detected Studio config does not contain both
-  values as string literals. Pass explicit `--project-id` and `--dataset` values or report the config
-  file and let the user decide whether to change it.
-- **Refusing to overwrite an existing path.** Inspect the reported Studio or Function directory.
-  Do not delete or replace it without the user's direction.
-- **Stack quota or duplicate-name error.** Local scaffold files may already exist while
-  `.sanity/blueprint.config.json` does not. Resolve the Stack error, then run the recovery command
-  printed by `init`, which is `blueprints init`. It connects the existing manifest without rewriting it.