@sanity/runtime-cli 17.1.0-next.g3cb2d2e → 17.1.0-next.gcfbd613

package/dist/cores/functions/test.js

@@ -1,5 +1,5 @@
 import { readFileSync } from 'node:fs';
-import { join } from 'node:path';
+import { dirname, join } from 'node:path';
 import { cwd } from 'node:process';
 import { testAction } from '../../actions/functions/test.js';
 import config from '../../config.js';
@@ -50,6 +50,7 @@ export async function functionTestCore(options) {
                 : undefined,
             logger: log,
         });
+        const blueprintFileDir = dirname(blueprint.fileInfo.blueprintFilePath);
         const contextOptions = docFunction || mediaFunction
             ? {
                 clientOptions: {
@@ -63,8 +64,9 @@ export async function functionTestCore(options) {
                 functionResourceType: 'project',
                 functionResourceId: projectId || '',
                 resources: resolvedResources,
+                blueprintFileDir,
             }
-            : { clientOptions: {}, resources: resolvedResources };
+            : { clientOptions: {}, resources: resolvedResources, blueprintFileDir };
         // If the user sets the flag to use the real token set it in our options
         if (withUserToken) {
             contextOptions.clientOptions.token = config.token || undefined;

package/dist/server/app.js

@@ -1,5 +1,6 @@
 import { existsSync, readFileSync, watchFile } from 'node:fs';
 import * as http from 'node:http';
+import { dirname } from 'node:path';
 import { default as mime } from 'mime-types';
 import { WebSocket, WebSocketServer } from 'ws';
 import { findBlueprintFile, loadAndParseBlueprint } from '../actions/blueprints/blueprint.js';
@@ -68,7 +69,11 @@ const app = (host, port, validateResources, executionOptions) => {
                     req.on('end', async () => {
                         res.setHeader('Content-Type', 'application/json');
                         try {
-                            const { data, func: functionName, metadata } = parseInvokeRequest(Buffer.concat(body));
+                            const fileInfo = findBlueprintFile();
+                            if (!fileInfo) {
+                                throw Error('Could not find a Blueprint manifest (sanity.blueprint.ts, .js, or .json). Run `blueprints init` to create one.');
+                            }
+                            const { data, func: functionName, metadata, } = parseInvokeRequest(Buffer.concat(body), dirname(fileInfo.blueprintFilePath));
                             const { context, event } = data;
                             // replace user token if required
                             if (isGroqContextOptions(context)) {
@@ -312,7 +317,7 @@ function buildApiUrl(projectId, dataset, docId, apiUrl) {
 function buildAssetUrl(mediaLibraryId, docId, apiUrl) {
     return `${apiUrl}/v2025-03-24/media-libraries/${mediaLibraryId}/doc/${docId}`;
 }
-function parseInvokeRequest(body) {
+function parseInvokeRequest(body, blueprintFileDir) {
     let json;
     try {
         json = JSON.parse(body.toString('utf8'));
@@ -404,6 +409,7 @@ function parseInvokeRequest(body) {
             context: {
                 ...context,
                 clientOptions,
+                blueprintFileDir,
                 // Provide default values for required properties if not present
                 eventResourceType: typeof context.eventResourceType === 'string' ? context.eventResourceType : '',
                 eventResourceId: typeof context.eventResourceId === 'string' ? context.eventResourceId : '',

package/dist/server/static/favicon-dark.svg

@@ -1,4 +1,5 @@
 <svg width="32" height="32" viewBox="0 0 32 32" fill="none" xmlns="http://www.w3.org/2000/svg">
+  <title>Sanity.io logo</title>
   <g clip-path="url(#clip0_2_1533)">
     <rect width="32" height="32" fill="#FFFFFF"/>
     <rect width="32" height="32" fill="#FFFFFF"/>

package/dist/server/static/favicon.svg

@@ -1,4 +1,5 @@
 <svg width="32" height="32" viewBox="0 0 32 32" fill="none" xmlns="http://www.w3.org/2000/svg">
+  <title>Sanity.io logo</title>
   <g clip-path="url(#clip0_2_1533)">
     <rect width="32" height="32" fill="#0B0B0B"/>
     <rect width="32" height="32" fill="#0B0B0B"/>

package/dist/server/static/index.html

@@ -33,7 +33,7 @@
         <filters-component></filters-component>
         <input type="checkbox" id="nav-toggle" class="hidden">
         <nav id="sidebar" class="relative y-scroll max-h-100 pad-t-5 border-right overflow-auto nav-min-width">
-          <label for="nav-toggle" id="nav-toggle-label" title="Toggle Functions list" class="z-10 nav-label"></label>
+          <label for="nav-toggle" id="nav-toggle-label" aria-label="Toggle Functions list" title="Toggle Functions list" class="z-10 nav-label"></label>
           <h4 class="config-label mar-t-0 mar-b-3 pad-l-3">Functions</h4>
           <function-list></function-list>
         </nav>

package/dist/server/static/vendor/vendor.bundle.js

@@ -6203,6 +6203,7 @@ class FacetProvider {
             }
         };
     }
+    get extension() { return this; }
 }
 function compareArray(a, b, compare) {
     if (a.length != b.length)
@@ -6400,6 +6401,7 @@ class PrecExtension {
         this.inner = inner;
         this.prec = prec;
     }
+    get extension() { return this; }
 }
 /**
 Extension compartments can be used to make a configuration
@@ -6434,6 +6436,7 @@ class CompartmentInstance {
         this.compartment = compartment;
         this.inner = inner;
     }
+    get extension() { return this; }
 }
 class Configuration {
     constructor(base, compartments, dynamicSlots, address, staticValues, facets) {
@@ -6543,6 +6546,8 @@ function flatten(extension, compartments, newCompartments) {
         else {
             let content = ext.extension;
             if (!content)
+                throw new Error(`Unrecognized extension value in extension set (${ext}).`);
+            if (content == ext)
                 throw new Error(`Unrecognized extension value in extension set (${ext}). This sometimes happens because multiple instances of @codemirror/state are loaded, breaking instanceof checks.`);
             inner(content, prec);
         }

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.
  */