@sanity/runtime-cli 17.1.0 → 17.2.0-blueprinit.gd1553d6

package/dist/utils/functions/child-runtime/resources.js

@@ -0,0 +1,59 @@
+/**
+ * The returned proxy wraps a function so the API itself is callable.
+ * @param {Record<string, ResourceEntry[]>} resources
+ * @returns {ResourcesApi}
+ */
+export function createResourcesApi(resources) {
+  const findByName = (name) => {
+    for (const group of Object.values(resources)) {
+      const found = group.find((r) => r.name === name)
+      if (found) return found
+    }
+    return undefined
+  }
+  let allCache
+  const all = () => (allCache ??= Object.values(resources).flat())
+
+  return /** @type {ResourcesApi} */ (
+    /** @type {unknown} */ (
+      /*
+       * The Proxy target is `findByName`, so invoking the API as a function —
+       * `context.resources('my-proj')` — bypasses the `get` trap entirely and
+       * calls `findByName` directly for a cross-type lookup by name.
+       */
+      new Proxy(findByName, {
+        get: (_target, prop) => {
+          // context.resources.all() — flat array of every resource across types
+          if (prop === 'all') return all
+          // [...context.resources] / for (const r of context.resources) — iterate all
+          if (prop === Symbol.iterator) {
+            return function* () {
+              yield* all()
+            }
+          }
+
+          /**
+           * Symbol property access (other than iterator above) and `then`
+           * lookups return undefined. The `then` guard prevents the API from
+           * looking like a thenable, so `await context.resources` resolves to
+           * the proxy itself rather than hanging or unwrapping unexpectedly.
+           */
+          if (typeof prop !== 'string' || prop === 'then') {
+            return undefined
+          }
+
+          /**
+           * context.resources.<type>(name) — per-type lookup,
+           * e.g. context.resources.project('my-proj').
+           * Returns a function so the caller supplies the name;
+           * unknown types yield a function that always returns undefined.
+           */
+          return (/** @type {string} */ name) =>
+            Object.hasOwn(resources, prop)
+              ? resources[prop].find((r) => r.name === name)
+              : undefined
+        },
+      })
+    )
+  )
+}

package/dist/utils/functions/find-entry-point.d.ts

@@ -8,4 +8,4 @@
  * @returns The absolute path to the entry file.
  * @throws If the entry file cannot be determined.
  */
-export declare function findFunctionEntryPoint(srcPath: string, displayName?: string): Promise<string>;
+export declare function findFunctionEntryPoint(functionPath: string, displayName?: string): Promise<string>;

package/dist/utils/functions/find-entry-point.js

@@ -1,6 +1,5 @@
 import { readFile, stat } from 'node:fs/promises';
 import { join, resolve } from 'node:path';
-import { cwd } from 'node:process';
 /**
  * Resolves the source path to an executable entry file path.
  *
@@ -11,27 +10,26 @@ import { cwd } from 'node:process';
  * @returns The absolute path to the entry file.
  * @throws If the entry file cannot be determined.
  */
-export async function findFunctionEntryPoint(srcPath, displayName) {
-    const absolutePath = resolve(cwd(), srcPath);
+export async function findFunctionEntryPoint(functionPath, displayName) {
     let stats;
     try {
-        stats = await stat(absolutePath);
+        stats = await stat(functionPath);
     }
     catch (err) {
-        throw new Error(`Source path not found or inaccessible: ${srcPath}`, { cause: err });
+        throw new Error(`Source path not found or inaccessible: ${functionPath}`, { cause: err });
     }
     if (stats.isFile()) {
         // It's already an entry file path
-        return absolutePath;
+        return functionPath;
     }
     if (stats.isDirectory()) {
         // 1. Check package.json#main
         try {
-            const pkgJsonPath = join(absolutePath, 'package.json');
+            const pkgJsonPath = join(functionPath, 'package.json');
             const pkgJsonContent = await readFile(pkgJsonPath, 'utf8');
             const pkgJson = JSON.parse(pkgJsonContent);
             if (pkgJson.main) {
-                const mainPath = resolve(absolutePath, pkgJson.main);
+                const mainPath = resolve(functionPath, pkgJson.main);
                 if (await fileExists(mainPath)) {
                     return mainPath;
                 }
@@ -43,20 +41,20 @@ export async function findFunctionEntryPoint(srcPath, displayName) {
             // Consider warning the user on invalid JSON though?
         }
         // 2. Check index.ts
-        const indexTs = join(absolutePath, 'index.ts');
+        const indexTs = join(functionPath, 'index.ts');
         if (await fileExists(indexTs)) {
             return indexTs;
         }
         // 3. Check index.js
-        const indexJs = join(absolutePath, 'index.js');
+        const indexJs = join(functionPath, 'index.js');
         if (await fileExists(indexJs)) {
             return indexJs;
         }
         const nameHint = displayName ? ` for function "${displayName}"` : '';
-        throw new Error(`Could not determine entry file${nameHint} in directory: ${srcPath}. Looked for package.json#main, index.ts, index.js.`);
+        throw new Error(`Could not determine entry file${nameHint} in directory: ${functionPath}. Looked for package.json#main, index.ts, index.js.`);
     }
     // Should not happen if stat succeeded, but defensively handle
-    throw new Error(`Source path is neither a file nor a directory: ${srcPath}`);
+    throw new Error(`Source path is neither a file nor a directory: ${functionPath}`);
 }
 /**
  * Checks if a file exists and is a file.

package/dist/utils/functions/invoke/local.js

@@ -66,7 +66,7 @@ export default async function invoke(resource, payload, context, options) {
     // Acquire a shared, reference-counted build. Concurrent invokes of the same
     // function reuse one transpile + temp package.json instead of racing on the
     // per-function build paths; the build is torn down once every invoke releases.
-    const build = acquireFunctionBuild(resource);
+    const build = acquireFunctionBuild(resource, context.blueprintFileDir);
     let functionPath;
     let bundleTimings;
     try {

package/dist/utils/functions/invoke/prepare.d.ts

@@ -17,4 +17,4 @@ export interface FunctionBuild {
  * caller MUST call `release()` exactly once when its child has exited, so the
  * shared artifacts are torn down only after the last in-flight invoke finishes.
  */
-export declare function acquireFunctionBuild(resource: FunctionResource): FunctionBuild;
+export declare function acquireFunctionBuild(resource: FunctionResource, blueprintFileDir: string): FunctionBuild;

package/dist/utils/functions/invoke/prepare.js

@@ -1,3 +1,4 @@
+import path from 'node:path';
 import { findFunctionEntryPoint } from '../find-entry-point.js';
 import { cleanupTempPackageJson, createTempPackageJson, doesPackageJsonExists, } from '../package-json.js';
 import { resolveResourceDependencies } from '../resolve-dependencies.js';
@@ -22,34 +23,44 @@ function buildKey(resource) {
  * caller MUST call `release()` exactly once when its child has exited, so the
  * shared artifacts are torn down only after the last in-flight invoke finishes.
  */
-export function acquireFunctionBuild(resource) {
+export function acquireFunctionBuild(resource, blueprintFileDir) {
     const key = buildKey(resource);
     let entry = builds.get(key);
     if (!entry) {
         let cleanupBundle = async () => { };
-        let functionPath = '';
+        const resolvedFunctionPath = path.resolve(blueprintFileDir, resource.src);
+        let functionPath = resolvedFunctionPath;
         let createdTempPackageJson = false;
         // If no package.json exists we create a temporary one to avoid the
         // "module type" warning from node.
-        const existingPackageJson = doesPackageJsonExists(resource);
+        const existingPackageJson = doesPackageJsonExists(functionPath);
         const ready = (async () => {
             if (!resource.src) {
                 throw new Error(`Function resource "${resource.name}" is missing the 'src' property.`);
             }
             let bundleTimings;
-            const shouldTranspile = await shouldTranspileFunction(resource);
-            if (shouldTranspile) {
-                const transpileResult = await transpileFunction(resource);
+            const shouldTranspile = await shouldTranspileFunction(resource, functionPath);
+            if (shouldTranspile.transpile) {
+                const transpileResult = await transpileFunction({
+                    resource,
+                    functionPath,
+                    entryPoint: shouldTranspile.entryPoint,
+                });
                 functionPath = await findFunctionEntryPoint(transpileResult.outputDir);
                 bundleTimings = transpileResult.timings;
                 cleanupBundle = transpileResult.cleanup;
             }
             else {
-                functionPath = await findFunctionEntryPoint(resource.src, resource.displayName ?? resource.name);
+                functionPath = await findFunctionEntryPoint(functionPath, resource.displayName ?? resource.name);
             }
             const shouldResolveDependencies = await shouldAutoResolveDependencies(resource);
             if (shouldResolveDependencies && existingPackageJson) {
-                await resolveResourceDependencies(resource, { transpiled: shouldTranspile });
+                await resolveResourceDependencies({
+                    resource,
+                    functionPath: resolvedFunctionPath,
+                    blueprintFileDir,
+                    transpiled: shouldTranspile.transpile,
+                });
             }
             if (!existingPackageJson) {
                 createTempPackageJson(functionPath);

package/dist/utils/functions/package-json.d.ts

@@ -1,4 +1,3 @@
-import type { FunctionResource } from '../types.js';
-export declare function doesPackageJsonExists(resource: FunctionResource): boolean;
+export declare function doesPackageJsonExists(functionPath: string): boolean;
 export declare function createTempPackageJson(functionPath: string): boolean;
 export declare function cleanupTempPackageJson(functionPath: string): boolean;

package/dist/utils/functions/package-json.js

@@ -1,17 +1,15 @@
 import { existsSync, rmSync, writeFileSync } from 'node:fs';
-import { dirname, join, resolve } from 'node:path';
-import { cwd } from 'node:process';
+import { dirname, join } from 'node:path';
 function getPackageJsonPath(functionPath) {
     const functionDir = dirname(functionPath);
     return join(functionDir, 'package.json');
 }
-export function doesPackageJsonExists(resource) {
-    if (!resource.src) {
+export function doesPackageJsonExists(functionPath) {
+    if (!functionPath) {
         // Cannot determine without a source path
         return false;
     }
-    const absolutePath = resolve(cwd(), resource.src);
-    const packageJsonPath = join(absolutePath, 'package.json');
+    const packageJsonPath = join(functionPath, 'package.json');
     return existsSync(packageJsonPath);
 }
 export function createTempPackageJson(functionPath) {

package/dist/utils/functions/prepare-asset.d.ts

@@ -1,6 +1,6 @@
 import type { AssetPrepResult, FunctionResource, InstallerType } from '../types.js';
-export declare function prepareAsset({ resource, }: {
+export declare function prepareAsset({ blueprintFileDir, resource, installer, }: {
+    blueprintFileDir: string;
     resource: FunctionResource;
-}, { installer }?: {
     installer?: InstallerType;
 }): Promise<AssetPrepResult>;

package/dist/utils/functions/prepare-asset.js

@@ -1,7 +1,6 @@
 import { existsSync } from 'node:fs';
 import { rm, stat } from 'node:fs/promises';
 import path from 'node:path';
-import { cwd } from 'node:process';
 import { MAX_ASSET_SIZE } from '../../constants.js';
 import { detectNativeModules, errorMessage } from './detect-native-modules.js';
 import { getFolderSize } from './get-folder-size.js';
@@ -9,16 +8,22 @@ import { resolveResourceDependencies } from './resolve-dependencies.js';
 import { shouldAutoResolveDependencies } from './should-auto-resolve-deps.js';
 import { shouldTranspileFunction } from './should-transpile.js';
 import { transpileFunction } from './transpile/function.js';
-export async function prepareAsset({ resource, }, { installer } = {}) {
+export async function prepareAsset({ blueprintFileDir, resource, installer, }) {
     if (!resource.src)
         throw new Error('Resource src is required');
-    let functionPath = path.join(cwd(), resource.src);
+    const resolvedFunctionPath = path.resolve(blueprintFileDir, resource.src);
+    let functionPath = resolvedFunctionPath;
     let cleanup = async () => { };
     let wasBundled = false;
-    const shouldTranspile = await shouldTranspileFunction(resource);
-    if (shouldTranspile) {
+    const shouldTranspile = await shouldTranspileFunction(resource, functionPath);
+    if (shouldTranspile.transpile) {
         try {
-            const result = await transpileFunction(resource, { installer });
+            const result = await transpileFunction({
+                resource,
+                functionPath,
+                entryPoint: shouldTranspile.entryPoint,
+                installer,
+            });
             functionPath = result.outputDir;
             cleanup = result.cleanup;
             wasBundled = result.bundled;
@@ -29,7 +34,13 @@ export async function prepareAsset({ resource, }, { installer } = {}) {
     }
     const shouldResolveDependencies = await shouldAutoResolveDependencies(resource);
     if (shouldResolveDependencies && !wasBundled) {
-        await resolveResourceDependencies(resource, { transpiled: shouldTranspile, installer });
+        await resolveResourceDependencies({
+            resource,
+            functionPath: resolvedFunctionPath,
+            blueprintFileDir,
+            transpiled: shouldTranspile.transpile,
+            installer,
+        });
         await removeArcAutoInstallPackageJson(functionPath);
     }
     if (existsSync(path.join(functionPath, 'node_modules'))) {

package/dist/utils/functions/resolve-dependencies.d.ts

@@ -1,5 +1,8 @@
 import type { FunctionResource, InstallerType } from '../types.js';
-export declare function resolveResourceDependencies(resource: FunctionResource, { transpiled, installer, }: {
+export declare function resolveResourceDependencies({ resource, transpiled, blueprintFileDir, functionPath, installer, }: {
+    resource: FunctionResource;
+    blueprintFileDir: string;
+    functionPath: string;
     transpiled: boolean;
     installer?: InstallerType;
 }): Promise<void>;

package/dist/utils/functions/resolve-dependencies.js

@@ -3,18 +3,17 @@ import { join } from 'node:path';
 import hydrate from '@architect/hydrate';
 import inventory from '@architect/inventory';
 import { convertResourceToArcFormat } from './resource-to-arc.js';
-export async function resolveResourceDependencies(resource, { transpiled, installer, }) {
-    const rawArc = await convertResourceToArcFormat(resource, transpiled);
-    const inv = await inventory({ rawArc });
-    const cwd = inv.inv._project.cwd;
+export async function resolveResourceDependencies({ resource, transpiled, blueprintFileDir, functionPath, installer, }) {
+    const rawArc = await convertResourceToArcFormat(resource, functionPath, transpiled);
+    const inv = await inventory({ rawArc, cwd: blueprintFileDir });
     let installType = 'npm';
     if (installer) {
         installType = installer;
     }
-    else if (existsSync(join(cwd, 'pnpm-lock.yaml'))) {
+    else if (existsSync(join(blueprintFileDir, 'pnpm-lock.yaml'))) {
         installType = 'pnpm';
     }
-    else if (existsSync(join(cwd, 'yarn.lock'))) {
+    else if (existsSync(join(blueprintFileDir, 'yarn.lock'))) {
         installType = 'yarn';
     }
     try {

package/dist/utils/functions/resource-to-arc.d.ts

@@ -1,2 +1,2 @@
 import type { FunctionResource } from '../types.js';
-export declare function convertResourceToArcFormat(resource: FunctionResource, transpiled: boolean): Promise<string>;
+export declare function convertResourceToArcFormat(resource: FunctionResource, functionPath: string, transpiled: boolean): Promise<string>;

package/dist/utils/functions/resource-to-arc.js

@@ -1,16 +1,15 @@
 import { stat } from 'node:fs/promises';
-import { resolve, sep } from 'node:path';
-import { cwd } from 'node:process';
-export async function convertResourceToArcFormat(resource, transpiled) {
+import { sep } from 'node:path';
+export async function convertResourceToArcFormat(resource, functionPath, transpiled) {
     if (!resource.src) {
         throw Error('Missing `resource.src` property');
     }
     // Get stats from file
-    const stats = await stat(resolve(cwd(), resource.src));
+    const stats = await stat(functionPath);
     // Convert resource.src to arc file path format
     const srcPath = resource.src?.split(sep).join('/');
     const entryDir = stats.isFile() ? srcPath.substring(0, srcPath.lastIndexOf('/')) : srcPath;
-    const functionPath = transpiled ? `${entryDir}/.build/function-${resource.name}` : entryDir;
+    functionPath = transpiled ? `${entryDir}/.build/function-${resource.name}` : entryDir;
     return `@app
 hydrate-function
 

package/dist/utils/functions/should-transpile.d.ts

@@ -1,2 +1,8 @@
 import type { FunctionResource } from '../types.js';
-export declare function shouldTranspileFunction(resource: FunctionResource): Promise<boolean>;
+export type ShouldTranspileResult = {
+    transpile: true;
+    entryPoint: string;
+} | {
+    transpile: false;
+};
+export declare function shouldTranspileFunction(resource: FunctionResource, functionPath: string): Promise<ShouldTranspileResult>;

package/dist/utils/functions/should-transpile.js

@@ -1,22 +1,22 @@
 import { findFunctionEntryPoint } from './find-entry-point.js';
-export async function shouldTranspileFunction(resource) {
-    if ('transpile' in resource && typeof resource.transpile === 'boolean') {
-        return resource.transpile;
-    }
-    if (!resource.src) {
-        // Cannot determine without a source path
-        return false;
+export async function shouldTranspileFunction(resource, functionPath) {
+    const hasTranspile = 'transpile' in resource && typeof resource.transpile === 'boolean';
+    if (!functionPath || (hasTranspile && resource.transpile === false)) {
+        return { transpile: false };
     }
     try {
         // 2. Find the actual entry point
-        const entryPoint = await findFunctionEntryPoint(resource.src, resource.displayName ?? resource.name);
+        const entryPoint = await findFunctionEntryPoint(functionPath, resource.displayName ?? resource.name);
         // 3. Check if the resolved entry point is a TypeScript file
-        return entryPoint.endsWith('.ts');
+        return {
+            entryPoint,
+            transpile: hasTranspile ? resource.transpile === true : entryPoint.endsWith('.ts'),
+        };
     }
     catch (err) {
         // If we cannot find the entry point, we cannot determine if it's TS.
         // Log a warning and default to false (don't bundle).
         console.warn(`[warn] Could not determine entry point for function "${resource.displayName ?? resource.name}" while checking if transpiling is needed: ${err instanceof Error ? err.message : err}`);
-        return false;
+        return { transpile: false };
     }
 }

package/dist/utils/functions/transpile/function.d.ts

@@ -1,6 +1,9 @@
 import type { FunctionResource, InstallerType } from '../../types.js';
 export declare const resolveViteRoot: (entry: string) => string;
-export declare function transpileFunction(resource: FunctionResource, { installer }?: {
+export declare function transpileFunction({ resource, functionPath, entryPoint, installer, }: {
+    resource: FunctionResource;
+    functionPath: string;
+    entryPoint: string;
     installer?: InstallerType;
 }): Promise<{
     type: string;

package/dist/utils/functions/transpile/function.js

@@ -3,9 +3,9 @@ import path from 'node:path';
 import { performance } from 'node:perf_hooks';
 import { cwd } from 'node:process';
 import * as find from 'empathic/find';
+import stripAnsi from 'strip-ansi';
 import { build as viteBuild } from 'vite';
 import { detectNativeModulesPlugin } from '../detect-native-modules.js';
-import { findFunctionEntryPoint } from '../find-entry-point.js';
 import { cleanupSourceMaps } from './cleanup-source-maps.js';
 import { createPnpmRequire } from './pnpm.js';
 import { verifyHandler } from './verify-handler.js';
@@ -13,23 +13,18 @@ export const resolveViteRoot = (entry) => {
     const nodeModulesDir = find.dir('node_modules', { cwd: entry });
     return nodeModulesDir ? path.dirname(nodeModulesDir) : entry;
 };
-export async function transpileFunction(resource, { installer } = {}) {
+export async function transpileFunction({ resource, functionPath, entryPoint, installer, }) {
     if (!resource.src)
         throw new Error('Resource src is required');
     if (!resource.name)
         throw new Error('Resource name is required');
     const timings = {};
     const transpileStart = performance.now();
-    const sourcePath = path.resolve(cwd(), resource.src);
-    const stats = await stat(sourcePath);
-    const fnDisplayName = resource.displayName ?? resource.name;
-    const findEntryStart = performance.now();
-    const entry = await findFunctionEntryPoint(sourcePath, fnDisplayName);
-    timings['transpile:findEntry'] = performance.now() - findEntryStart;
-    const entryDir = stats.isFile() ? path.dirname(sourcePath) : sourcePath;
+    const stats = await stat(functionPath);
+    const entryDir = stats.isFile() ? path.dirname(functionPath) : functionPath;
     const outputPathStart = performance.now();
     const outputDir = await getTranspileOutputPath(entryDir, resource.name);
-    const outputFile = path.join(outputDir, getOutputFilename(entry));
+    const outputFile = path.join(outputDir, getOutputFilename(entryPoint));
     const fnRootDir = resolveViteRoot(entryDir);
     timings['transpile:setupOutput'] = performance.now() - outputPathStart;
     async function cleanupTmpDir() {
@@ -51,10 +46,10 @@ export async function transpileFunction(resource, { installer } = {}) {
                 sourcemap: true,
                 ssr: true,
                 rolldownOptions: {
-                    input: entry,
+                    input: entryPoint,
                     output: {
                         format: 'esm',
-                        entryFileNames: getOutputFilename(entry),
+                        entryFileNames: getOutputFilename(entryPoint),
                         ...(bundle
                             ? {}
                             : {
@@ -86,7 +81,7 @@ export async function transpileFunction(resource, { installer } = {}) {
         await writeTranspiledPackageJson(entryDir, outputFile);
         timings['transpile:writePackage'] = performance.now() - pkgStart;
         const cleanupStart = performance.now();
-        await cleanupSourceMaps(sourcePath, outputDir);
+        await cleanupSourceMaps(functionPath, outputDir);
         timings['transpile:cleanupMaps'] = performance.now() - cleanupStart;
         timings.bundle = performance.now() - transpileStart;
         return {
@@ -100,7 +95,7 @@ export async function transpileFunction(resource, { installer } = {}) {
     }
     catch (err) {
         await cleanupTmpDir();
-        throw new Error(`Transpiling of function failed: ${formatBuildError(err)}`, {
+        throw new Error(`Transpiling of function failed: ${stripAnsi(formatBuildError(err))}`, {
             cause: err,
         });
     }

package/dist/utils/functions/transpile/verify-handler.js

@@ -4,7 +4,7 @@ export async function verifyHandler(result) {
     }
     const outputs = (Array.isArray(result) ? result : [result]).flatMap(({ output }) => output);
     const bundledIndex = outputs.find((output) => output.type === 'chunk' && output.isEntry && output.fileName === 'index.js');
-    if (!bundledIndex || bundledIndex.type !== 'chunk') {
+    if (bundledIndex?.type !== 'chunk') {
         throw new Error('Unexpected build output, no bundled index found');
     }
     if (!bundledIndex.exports.includes('handler')) {

package/dist/utils/logger.d.ts

@@ -6,11 +6,13 @@ export declare function Logger(log: (msg: string) => void, flags?: {
 }): {
     (msg: string): void;
     isTraceEnabled: boolean;
-    trace(formatter: unknown, ...args: unknown[]): false | void;
-    verbose(formatter: unknown, ...args: unknown[]): false | void;
-    info(formatter: unknown, ...args: unknown[]): false | void;
-    warn(formatter: unknown, ...args: unknown[]): false | void;
-    error(formatter: unknown, ...args: unknown[]): false | void;
+    trace: (formatter: unknown, ...args: unknown[]) => void | false;
+    verbose: (formatter: unknown, ...args: unknown[]) => void | false;
+    info: (formatter: unknown, ...args: unknown[]) => void | false;
+    warn: (formatter: unknown, ...args: unknown[]) => void | false;
+    error: (formatter: unknown, ...args: unknown[]) => void | false;
+    showProgress: (percent?: number) => void;
+    clearProgress: () => void;
     ora: typeof ora;
 };
 export type Logger = ReturnType<typeof Logger>;

package/dist/utils/logger.js

@@ -1,5 +1,6 @@
 import { format } from 'node:util';
 import ora from 'ora';
+import { clearProgress, showBusy, showError, showProgress } from './progress.js';
 var LogLevel;
 (function (LogLevel) {
     LogLevel[LogLevel["TRACE"] = 0] = "TRACE";
@@ -19,16 +20,47 @@ export function Logger(log, flags = {}) {
     logger.info = (formatter, ...args) => level <= LogLevel.INFO && logger(format(formatter, ...args));
     logger.warn = (formatter, ...args) => level <= LogLevel.WARN && logger(format(formatter, ...args));
     logger.error = (formatter, ...args) => level <= LogLevel.ERROR && logger(format(formatter, ...args));
+    logger.showProgress = (percent) => {
+        if (flags.json)
+            return;
+        if (percent === undefined)
+            showBusy();
+        else
+            showProgress(percent);
+    };
+    logger.clearProgress = () => {
+        if (flags.json)
+            return;
+        clearProgress();
+    };
     const oraWrapper = (opts) => {
         if (flags.json)
             return createOraLineLoggingWrapper(opts, logger);
         if (level >= LogLevel.INFO)
-            return ora(opts);
+            return withTerminalProgress(ora(opts));
         return createOraLineLoggingWrapper(opts, logger);
     };
     logger.ora = oraWrapper;
     return logger;
 }
+function withTerminalProgress(spinner) {
+    const wrap = (name, effect) => {
+        if (typeof spinner[name] !== 'function')
+            return;
+        const original = spinner[name].bind(spinner);
+        spinner[name] = (...args) => {
+            const result = original(...args);
+            effect();
+            return result;
+        };
+    };
+    wrap('start', showBusy);
+    wrap('fail', showError);
+    for (const name of ['stop', 'succeed', 'warn', 'info', 'stopAndPersist']) {
+        wrap(name, clearProgress);
+    }
+    return spinner;
+}
 /**
  * An ora-like wrapper that uses standard line output logging instead of rendering a spinner; used in verbose and trace modes.
  */

package/dist/utils/progress.d.ts

@@ -0,0 +1,5 @@
+export declare function showProgress(percent: number): void;
+export declare function showBusy(): void;
+export declare function showError(): void;
+export declare function showPaused(percent: number): void;
+export declare function clearProgress(): void;

package/dist/utils/progress.js

@@ -0,0 +1,40 @@
+import { stderr } from 'node:process';
+import { onExit } from 'signal-exit';
+const ST = '\x1b\\';
+const STATES = {
+    clear: 0,
+    normal: 1,
+    error: 2,
+    paused: 4,
+    busy: 3,
+};
+let exitHookRegistered = false;
+function write(state, value = 0) {
+    if (!stderr.isTTY)
+        return;
+    if (!exitHookRegistered) {
+        exitHookRegistered = true;
+        function clear() {
+            stderr.write(`\x1b]9;4;0;0${ST}`);
+        }
+        // arc/utils SIGINT handler clobbers our signal-exit; luckily it then calls process.exit()
+        process.once('exit', clear); // triggered by arc/utils SIGINT handler
+        onExit(clear); // triggered by all other exit paths
+    }
+    stderr.write(`\x1b]9;4;${STATES[state]};${Math.round(value)}${ST}`);
+}
+export function showProgress(percent) {
+    write('normal', Math.max(0, Math.min(100, percent)));
+}
+export function showBusy() {
+    write('busy');
+}
+export function showError() {
+    write('error', 100);
+}
+export function showPaused(percent) {
+    write('paused', Math.max(0, Math.min(100, percent)));
+}
+export function clearProgress() {
+    write('clear');
+}

package/dist/utils/studios/prepare-asset.d.ts

@@ -0,0 +1,6 @@
+import type { BlueprintStudioResource } from '@sanity/blueprints';
+import type { AssetPrepResult } from '../types.js';
+export declare function prepareStudioAsset({ blueprintFileDir, resource, }: {
+    blueprintFileDir: string;
+    resource: BlueprintStudioResource;
+}): Promise<AssetPrepResult>;