@sanity/runtime-cli 4.4.0 → 4.5.1

package/dist/commands/functions/invoke.js

@@ -1,11 +1,10 @@
-import { Args, Command, Flags } from '@oclif/core';
+import { Args, Flags } from '@oclif/core';
 import Spinner from 'yocto-spinner';
-import { readBlueprintOnDisk } from '../../actions/blueprints/blueprint.js';
 import { invoke } from '../../actions/functions/invoke.js';
+import { DeployedBlueprintCommand } from '../../baseCommands.js';
 import { red } from '../../utils/display/colors.js';
 import { findFunctionByName } from '../../utils/find-function.js';
-import { validTokenOrErrorMessage } from '../../utils/validated-token.js';
-export default class Invoke extends Command {
+export default class InvokeCommand extends DeployedBlueprintCommand {
     static args = {
         name: Args.string({ description: 'The name of the Sanity Function', required: true }),
     };
@@ -23,17 +22,11 @@ export default class Invoke extends Command {
         }),
     };
     async run() {
-        const { token, error: tokenErr } = await validTokenOrErrorMessage();
-        if (tokenErr)
-            this.error(tokenErr.message);
-        const { args, flags } = await this.parse(Invoke);
+        const args = this.args;
+        const flags = this.flags;
         const spinner = Spinner({ text: `Invoking function "${args.name}"` }).start();
-        const { deployedStack } = await readBlueprintOnDisk({ getStack: true, token });
-        if (!deployedStack)
-            this.error('Stack not found'); // returns
-        const { projectId } = deployedStack;
-        const { externalId } = findFunctionByName(deployedStack, args.name);
-        const result = await invoke(externalId, { data: flags.data, file: flags.file }, { token, projectId });
+        const { externalId } = findFunctionByName(this.deployedStack, args.name);
+        const result = await invoke(externalId, { data: flags.data, file: flags.file }, this.auth);
         if (result.ok) {
             spinner.success(`Invocation of ${args.name} succeeded`);
             if (result.json?.data?.type === 'Buffer') {

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

@@ -1,4 +1,4 @@
-import { Command } from '@oclif/core';
+import { DeployedBlueprintCommand } from '../../baseCommands.js';
 type RunDeleteOptions = {
     force: boolean;
 };
@@ -6,7 +6,7 @@ type RunGetOptions = {
     limit: number;
     json?: boolean;
 };
-export default class Logs extends Command {
+export default class LogsCommand extends DeployedBlueprintCommand<typeof LogsCommand> {
     static args: {
         name: import("@oclif/core/interfaces").Arg<string, Record<string, unknown>>;
     };
@@ -18,13 +18,9 @@ export default class Logs extends Command {
         delete: import("@oclif/core/interfaces").BooleanFlag<boolean>;
         force: import("@oclif/core/interfaces").BooleanFlag<boolean>;
     };
-    sanityToken: string | undefined;
+    externalId: string | undefined;
     run(): Promise<void>;
     runDeleteLogs(name: string, options: RunDeleteOptions): Promise<void>;
     runGetLogs(name: string, options: RunGetOptions): Promise<void>;
-    getProjectAndExternalId(name: string): Promise<{
-        projectId?: string;
-        externalId?: string;
-    }>;
 }
 export {};

package/dist/commands/functions/logs.js

@@ -1,12 +1,11 @@
-import { Args, Command, Flags } from '@oclif/core';
+import { Args, Flags } from '@oclif/core';
 import inquirer from 'inquirer';
 import Spinner from 'yocto-spinner';
-import { readBlueprintOnDisk } from '../../actions/blueprints/blueprint.js';
-import { deleteLogs as deleteLogsAction, logs as logsAction } from '../../actions/functions/logs.js';
+import { deleteLogs as deleteLogsAction, logs as getLogsAction, } from '../../actions/functions/logs.js';
+import { DeployedBlueprintCommand } from '../../baseCommands.js';
 import { formatTitle } from '../../utils/display/blueprints-formatting.js';
 import { blue, bold, green, red, yellow } from '../../utils/display/colors.js';
 import { findFunctionByName } from '../../utils/find-function.js';
-import { validTokenOrErrorMessage } from '../../utils/validated-token.js';
 function logLevel(level) {
     if (level === 'ERROR') {
         return red(level);
@@ -16,7 +15,7 @@ function logLevel(level) {
     }
     return green(level);
 }
-export default class Logs extends Command {
+export default class LogsCommand extends DeployedBlueprintCommand {
     static args = {
         name: Args.string({ description: 'The name of the Sanity Function', required: true }),
     };
@@ -52,13 +51,12 @@ export default class Logs extends Command {
             required: false,
         }),
     };
-    sanityToken;
+    externalId;
     async run() {
-        const { token, error: tokenErr } = await validTokenOrErrorMessage();
-        if (tokenErr)
-            this.error(tokenErr.message);
-        this.sanityToken = token;
-        const { args, flags } = await this.parse(Logs);
+        const args = this.args;
+        const flags = this.flags;
+        const { externalId } = findFunctionByName(this.deployedStack, args.name);
+        this.externalId = externalId;
         if (flags.delete === true) {
             await this.runDeleteLogs(args.name, flags);
         }
@@ -67,6 +65,8 @@ export default class Logs extends Command {
         }
     }
     async runDeleteLogs(name, options) {
+        if (!this.externalId)
+            this.error('Unable to delete logs. Unable to determine function ID.');
         if (!options.force) {
             const { certain } = await inquirer.prompt({
                 type: 'confirm',
@@ -77,14 +77,8 @@ export default class Logs extends Command {
             if (!certain)
                 return;
         }
-        const { projectId, externalId } = await this.getProjectAndExternalId(name);
-        if (!projectId || !externalId) {
-            this.error('Stack not found');
-        }
-        if (!this.sanityToken)
-            this.error('Unable to delete logs. Missing API token.');
         const spinner = Spinner({ text: `Deleting logs for function ${yellow(name)}` }).start();
-        const { ok, error } = await deleteLogsAction(externalId, { token: this.sanityToken, projectId });
+        const { ok, error } = await deleteLogsAction(this.externalId, this.auth);
         if (!ok) {
             spinner.error(`${red('Failed')} to retrieve logs`);
             this.log(`Error: ${error || 'Unknown error'}`);
@@ -93,14 +87,10 @@ export default class Logs extends Command {
         spinner.success('Logs deleted');
     }
     async runGetLogs(name, options) {
+        if (!this.externalId)
+            this.error('Unable to retrieve logs. Unable to determine function ID.');
         const spinner = Spinner({ text: `Finding logs for function "${name}"` }).start();
-        const { projectId, externalId } = await this.getProjectAndExternalId(name);
-        if (!projectId || !externalId) {
-            this.error('Stack not found');
-        }
-        if (!this.sanityToken)
-            this.error('Unable to retrieve logs. Missing API token.');
-        const { ok, error, logs, total } = await logsAction(externalId, { limit: options.limit }, { token: this.sanityToken, projectId });
+        const { ok, error, logs, total } = await getLogsAction(this.externalId, { limit: options.limit }, this.auth);
         if (!ok) {
             spinner.error(`${red('Failed')} to retrieve logs`);
             this.log(`Error: ${error || 'Unknown error'}`);
@@ -121,22 +111,16 @@ export default class Logs extends Command {
             for (const log of filteredLogs) {
                 const { time, level, message } = log;
                 const date = new Date(time);
-                this.log(`${bold(date.toLocaleDateString())} ${bold(blue(date.toLocaleTimeString()))} ${logLevel(level)} ${message}`);
+                this.log([
+                    bold(date.toLocaleDateString()),
+                    bold(blue(date.toLocaleTimeString())),
+                    logLevel(level),
+                    message,
+                ].join(' '));
             }
         }
         else {
             this.log(JSON.stringify(filteredLogs, null, 2));
         }
     }
-    async getProjectAndExternalId(name) {
-        if (!this.sanityToken)
-            this.error('Missing API token.');
-        const { deployedStack } = await readBlueprintOnDisk({ getStack: true, token: this.sanityToken });
-        if (!deployedStack) {
-            return {};
-        }
-        const { projectId } = deployedStack;
-        const { externalId } = findFunctionByName(deployedStack, name);
-        return { projectId, externalId };
-    }
 }

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

@@ -1,5 +1,5 @@
-import { Command } from '@oclif/core';
-export default class Test extends Command {
+import { BlueprintCommand } from '../../baseCommands.js';
+export default class TestCommand extends BlueprintCommand<typeof TestCommand> {
     static args: {
         name: import("@oclif/core/interfaces").Arg<string, Record<string, unknown>>;
     };
@@ -11,7 +11,7 @@ export default class Test extends Command {
         timeout: import("@oclif/core/interfaces").OptionFlag<number | undefined, import("@oclif/core/interfaces").CustomOptions>;
         api: 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>;
-        project: 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>;
     };
     run(): Promise<void>;
 }

package/dist/commands/functions/test.js

@@ -1,8 +1,8 @@
-import { Args, Command, Flags } from '@oclif/core';
-import { readBlueprintOnDisk } from '../../actions/blueprints/blueprint.js';
+import { Args, Flags } from '@oclif/core';
 import { testAction } from '../../actions/functions/test.js';
-import { getFunctionSource } from '../../utils/find-function.js';
-export default class Test extends Command {
+import { BlueprintCommand } from '../../baseCommands.js';
+import { findFunctionByName } from '../../utils/find-function.js';
+export default class TestCommand extends BlueprintCommand {
     static args = {
         name: Args.string({ description: 'The name of the Sanity Function', required: true }),
     };
@@ -33,20 +33,19 @@ export default class Test extends Command {
             description: 'The Sanity dataset to use',
             required: false,
         }),
-        project: Flags.string({
-            description: 'The Sanity project to use',
+        'project-id': Flags.string({
+            description: 'Sanity Project ID to use',
+            aliases: ['project', 'projectId'],
             required: false,
         }),
     };
     async run() {
-        const { args, flags } = await this.parse(Test);
-        const { parsedBlueprint } = await readBlueprintOnDisk({ getStack: false });
+        const args = this.args;
+        const flags = this.flags;
+        const parsedBlueprint = this.blueprint.parsedBlueprint;
         try {
-            const src = getFunctionSource(parsedBlueprint, args.name);
-            if (!src) {
-                this.error(`Error: Function ${args.name} has no source code`);
-            }
-            const { json, logs, error } = await testAction(src, {
+            const resource = findFunctionByName(parsedBlueprint, args.name);
+            const { json, logs, error } = await testAction(resource, {
                 data: flags.data,
                 file: flags.file,
                 timeout: flags.timeout,
@@ -54,7 +53,7 @@ export default class Test extends Command {
                 clientOptions: {
                     apiVersion: flags.api,
                     dataset: flags.dataset,
-                    projectId: flags.project,
+                    projectId: flags['project-id'],
                 },
             });
             if (!error) {

package/dist/server/app.js

@@ -1,9 +1,11 @@
 import { existsSync, readFileSync } from 'node:fs';
+import * as http from 'node:http';
 import { default as mime } from 'mime-types';
-import { readBlueprintOnDisk } from '../actions/blueprints/blueprint.js';
+import { readLocalBlueprint } from '../actions/blueprints/blueprint.js';
 import config from '../config.js';
+import { findFunctionByName } from '../utils/find-function.js';
 import invoke from '../utils/invoke-local.js';
-import * as http from 'node:http';
+import { isRecord } from '../utils/is-record.js';
 const host = 'localhost';
 const app = (port) => {
     const requestListener = async (req, res) => {
@@ -11,33 +13,43 @@ const app = (port) => {
         switch (true) {
             case req.url === '/blueprint': {
                 try {
-                    const { parsedBlueprint } = await readBlueprintOnDisk({ getStack: false });
+                    const { parsedBlueprint } = await readLocalBlueprint();
                     res.setHeader('Content-Type', 'application/json');
                     res.writeHead(200);
-                    res.end(JSON.stringify(parsedBlueprint));
+                    res.end(JSON.stringify(parsedBlueprint)); // Use parsedBlueprint directly
                 }
-                catch {
+                catch (error) {
                     res.writeHead(404);
-                    res.end();
+                    res.end(JSON.stringify({ error: error instanceof Error ? error.message : 'Unknown error' }));
                 }
                 break;
             }
             case req.url === '/invoke': {
                 if (req.method === 'POST') {
-                    let body = '';
-                    req.on('data', (data) => {
-                        body += data;
-                    });
+                    const body = [];
+                    req.on('data', (data) => body.push(data));
                     req.on('end', async () => {
-                        const { data, func } = JSON.parse(body);
-                        const { context, event } = data;
                         res.setHeader('Content-Type', 'application/json');
                         try {
-                            const response = await invoke(func, event, context);
-                            res.writeHead(200);
+                            const { data, func: functionName } = parseInvokeRequest(Buffer.concat(body));
+                            const { context, event } = data;
+                            const start = performance.now();
+                            const { parsedBlueprint } = await readLocalBlueprint();
+                            const resource = findFunctionByName(parsedBlueprint, functionName);
+                            const readBlueprintTime = performance.now() - start;
+                            const response = await invoke(resource, event, context);
+                            const timings = { ...response.timings, 'blueprint:read': readBlueprintTime };
+                            const timingHeaders = [];
+                            for (const [key, value] of Object.entries(timings)) {
+                                timingHeaders.push(`${key.replace(/:/g, '-')};dur=${Math.abs(value).toFixed(1)}`);
+                            }
+                            if (timingHeaders.length > 0) {
+                                res.setHeader('Server-Timing', timingHeaders.join(', '));
+                            }
                             res.end(JSON.stringify(response));
                         }
                         catch (error) {
+                            console.error(error);
                             const response = { logs: '', error: '' };
                             if (error instanceof Error) {
                                 response.logs = error.message;
@@ -112,4 +124,60 @@ const app = (port) => {
     const server = http.createServer(requestListener);
     server.listen(port, host, () => { });
 };
+function parseInvokeRequest(body) {
+    let json;
+    try {
+        json = JSON.parse(body.toString('utf8'));
+    }
+    catch (error) {
+        throw new Error('Request body is not valid JSON', { cause: error });
+    }
+    if (!isRecord(json)) {
+        throw new Error('Request body is not valid, must be an object');
+    }
+    if (!('func' in json)) {
+        throw new Error('Request body is not valid, missing `func` field');
+    }
+    if (!('data' in json)) {
+        throw new Error('Request body is not valid, missing `data` field');
+    }
+    const { data, func } = json;
+    if (typeof func !== 'string') {
+        throw new Error('Request body is not valid, `func` field is not a string');
+    }
+    if (!isRecord(data)) {
+        throw new Error('Request body is not valid, `data` field is not an object');
+    }
+    const { context, event } = data;
+    if (!isRecord(context)) {
+        throw new Error('Request body is not valid, `context` field is not an object');
+    }
+    if (!isRecord(event)) {
+        throw new Error('Request body is not valid, `event` field is not an object');
+    }
+    if (!('clientOptions' in context)) {
+        throw new Error('Request body is not valid, `context.clientOptions` field is missing');
+    }
+    if (!isRecord(context.clientOptions)) {
+        throw new Error('Request body is not valid, `context.clientOptions` field is not an object');
+    }
+    const { projectId, dataset, apiVersion } = context.clientOptions;
+    if (typeof projectId !== 'string' && typeof projectId !== 'undefined') {
+        throw new Error('Request body is not valid, `context.clientOptions.projectId` field is not a string');
+    }
+    if (typeof dataset !== 'string' && typeof dataset !== 'undefined') {
+        throw new Error('Request body is not valid, `context.clientOptions.dataset` field is not a string');
+    }
+    if (typeof apiVersion !== 'string' && typeof apiVersion !== 'undefined') {
+        throw new Error('Request body is not valid, `context.clientOptions.apiVersion` field is not a string');
+    }
+    const clientOptions = {
+        ...context.clientOptions,
+        projectId,
+        dataset,
+        // Prefer `undefined` over empty string, triggering the right warnings in the client
+        apiVersion: apiVersion || undefined,
+    };
+    return { func, data: { context: { ...context, clientOptions }, event } };
+}
 export default app;

package/dist/server/static/api.js

@@ -30,12 +30,15 @@ function invoke(payloadText = '{}') {
     },
     method: 'POST',
   })
-    .then((response) => response.json())
-    .then((data) => {
+    .then((response) => {
+      return response.json().then((data) => ({data, timings: getServerTimings(response)}))
+    })
+    .then(({data, timings}) => {
       store.inprogress = false
       store.result = {
         ...data,
         time: Date.now() - start,
+        timings,
       }
     })
 }
@@ -47,7 +50,7 @@ function blueprint() {
       const functions = blueprint?.resources.filter((r) => r.type.startsWith('sanity.function.'))
 
       store.functions = functions
-      store.selectedIndex = functions[0].src
+      store.selectedIndex = functions[0].name
     })
     .catch(() => {
       store.functions = []
@@ -77,3 +80,21 @@ function datasets(selectedProject) {
       store.datasets = []
     })
 }
+
+function getServerTimings(response) {
+  const timings = {}
+  const serverTiming = response.headers.get('Server-Timing')
+  if (!serverTiming) {
+    return timings
+  }
+
+  for (const entry of serverTiming.split(',')) {
+    const [name, ...params] = entry.split(';')
+    const durationParam = params.find((p) => p.startsWith('dur='))
+    if (durationParam) {
+      timings[name.trim()] = Number.parseFloat(durationParam.slice(4))
+    }
+  }
+
+  return timings
+}

package/dist/server/static/components/function-list.js

@@ -9,7 +9,7 @@ class FunctionList extends ApiBaseElement {
   functionClicked = (event) => {
     // eslint-disable-next-line unicorn/prefer-dom-node-text-content
     const target = this.api.store.functions.find((func) => func.name === event.srcElement.innerText)
-    this.api.store.selectedIndex = target.src
+    this.api.store.selectedIndex = target.name
   }
   functionSelected = (event) => {
     this.api.store.selectedIndex = event.srcElement.value
@@ -18,14 +18,14 @@ class FunctionList extends ApiBaseElement {
     if (this.api.store.functions.length > 0) {
       this.list.innerHTML = this.api.store.functions
         .map((func) => {
-          const selected = this.api.store.selectedIndex === func.src ? 'selected' : ''
+          const selected = this.api.store.selectedIndex === func.name ? 'selected' : ''
           return `<li class="function-list-item ${selected}" style="padding: 16px 24px;">${func.name}</li>`
         })
         .join('')
       this.select.innerHTML = this.api.store.functions
         .map((func) => {
-          const selected = this.api.store.selectedIndex === func.src ? 'selected' : ''
-          return `<option value="${func.src}" ${selected}>${func.name}</option>`
+          const selected = this.api.store.selectedIndex === func.name ? 'selected' : ''
+          return `<option value="${func.name}" ${selected}>${func.name}</option>`
         })
         .join('')
     } else {

package/dist/server/static/components/response-panel.js

@@ -34,7 +34,7 @@ class ResponsePanel extends ApiBaseElement {
   updateResponse = ({result}) => {
     if (!result) return
 
-    const {error, json, time} = result
+    const {error, json, logs, time, timings} = result
     if (!error) {
       const transaction = this.api.store.response.state.update({
         changes: {
@@ -46,8 +46,19 @@ class ResponsePanel extends ApiBaseElement {
       this.api.store.response.dispatch(transaction)
 
       this.size.innerText = json ? prettyBytes(JSON.stringify(json).length) : ''
-      this.time.innerText = prettyMilliseconds(time)
-      this.time.dateTime = `PT${time / 1000}S`
+
+      if (timings && 'bundle' in timings && 'execute' in timings) {
+        const bundleTime = prettyMilliseconds(timings.bundle)
+        const executeTime = prettyMilliseconds(timings.execute)
+        this.time.innerText = `${executeTime} (+${bundleTime} bundle time)`
+        this.time.dateTime = `PT${executeTime / 1000}S`
+      } else if (timings && 'execute' in timings) {
+        this.time.innerText = prettyMilliseconds(timings.execute)
+        this.time.dateTime = `PT${timings.execute / 1000}S`
+      } else {
+        this.time.innerText = prettyMilliseconds(time)
+        this.time.dateTime = `PT${time / 1000}S`
+      }
     } else {
       const transaction = this.api.store.response.state.update({
         changes: {from: 0, to: this.api.store.response.state.doc.length, insert: ''},

package/dist/server/static/index.html

@@ -1,6 +1,7 @@
 <!DOCTYPE html>
 <html>
     <head>
+        <meta charset="UTF-8">
         <title>Sanity Functions</title>
         <link href="https://unpkg.com/m-@3.2.0/dist/m-.woff2" rel="preload" as="font" crossorigin>
         <link href="https://unpkg.com/m-@3.2.0/dist/m-.css" rel="stylesheet">

package/dist/utils/build-payload.d.ts

@@ -1,2 +1,2 @@
 import type { InvokePayloadOptions } from './types.js';
-export default function buildPayload(options: InvokePayloadOptions): object | null;
+export default function buildPayload(options: InvokePayloadOptions): Record<string, unknown> | null;

package/dist/utils/build-payload.js

@@ -1,15 +1,15 @@
 import { readFileSync } from 'node:fs';
 import { join } from 'node:path';
 import { cwd } from 'node:process';
-import isJson from './is-json.js';
+import { parseJsonObject } from './parse-json-object.js';
 export default function buildPayload(options) {
     const { data, file } = options;
     let payload = {};
     if (data) {
-        payload = isJson(data);
+        payload = parseJsonObject(data);
     }
     else if (file) {
-        payload = isJson(readFileSync(join(cwd(), file), 'utf8'));
+        payload = parseJsonObject(readFileSync(join(cwd(), file), 'utf8'));
     }
     return payload;
 }

package/dist/utils/bundle/bundle-function.d.ts

@@ -0,0 +1,8 @@
+import type { LocalFunctionResource } from '../types.js';
+export declare function bundleFunction(resource: LocalFunctionResource): Promise<{
+    type: string;
+    outputDir: string;
+    warnings: string[];
+    cleanup: () => Promise<void>;
+    timings: Record<string, number>;
+}>;

package/dist/utils/bundle/bundle-function.js

@@ -0,0 +1,125 @@
+import { mkdir, readFile, rm, stat, writeFile } from 'node:fs/promises';
+import path from 'node:path';
+import { performance } from 'node:perf_hooks';
+import { cwd } from 'node:process';
+import { build as viteBuild } from 'vite';
+import tsConfigPaths from 'vite-tsconfig-paths';
+import { findFunctionEntryPoint } from '../functions/find-entry-point.js';
+import { cleanupSourceMaps } from './cleanup-source-maps.js';
+import { findDirUp } from './find-up.js';
+import { verifyHandler } from './verify-handler.js';
+export async function bundleFunction(resource) {
+    if (!resource.src)
+        throw new Error('Resource src is required');
+    if (!resource.name)
+        throw new Error('Resource name is required');
+    const timings = {};
+    const bundleStart = 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['bundle:findEntry'] = performance.now() - findEntryStart;
+    const entryDir = stats.isFile() ? path.dirname(sourcePath) : sourcePath;
+    const outputPathStart = performance.now();
+    const outputDir = await getBundleOutputPath(entryDir, resource.name);
+    const outputFile = path.join(outputDir, getOutputFilename(entry));
+    const fnRootDir = (await findDirUp('node_modules', entryDir)) || entryDir;
+    timings['bundle:setupOutput'] = performance.now() - outputPathStart;
+    async function cleanupTmpDir() {
+        // Feel a certain way about leaving things uncleaned, but helps with debugging for now
+        // await rm(outputDir, {recursive: true, force: true}).catch(logCleanupFailure)
+    }
+    try {
+        const viteStart = performance.now();
+        const result = await viteBuild({
+            root: fnRootDir,
+            logLevel: 'silent',
+            build: {
+                target: 'node20',
+                outDir: outputDir,
+                emptyOutDir: false,
+                minify: false,
+                sourcemap: true,
+                ssr: true,
+                rollupOptions: {
+                    input: entry,
+                    output: {
+                        format: 'esm',
+                        entryFileNames: getOutputFilename(entry),
+                    },
+                },
+            },
+            ssr: {
+                noExternal: true,
+                resolve: {
+                    conditions: ['sanity-function', 'vite'],
+                },
+            },
+            plugins: [tsConfigPaths()],
+        });
+        timings['bundle:build'] = performance.now() - viteStart;
+        const verifyStart = performance.now();
+        await verifyHandler(result);
+        timings['bundle:verify'] = performance.now() - verifyStart;
+        const pkgStart = performance.now();
+        await writeBundledPackageJson(entryDir, outputFile);
+        timings['bundle:writePackage'] = performance.now() - pkgStart;
+        const cleanupStart = performance.now();
+        await cleanupSourceMaps(sourcePath, outputDir);
+        timings['bundle:cleanupMaps'] = performance.now() - cleanupStart;
+        timings.bundle = performance.now() - bundleStart;
+        return {
+            type: 'success',
+            outputDir,
+            warnings: [],
+            cleanup: cleanupTmpDir,
+            timings,
+        };
+    }
+    catch (err) {
+        await cleanupTmpDir();
+        throw new Error(`Bundling of function failed: ${err instanceof Error ? err.message : err}`, {
+            cause: err,
+        });
+    }
+}
+async function writeBundledPackageJson(inputDir, outputFilePath) {
+    const baseName = path.basename(outputFilePath);
+    let original;
+    try {
+        const pkgJsonPath = path.join(inputDir, 'package.json');
+        original = JSON.parse(await readFile(pkgJsonPath, 'utf-8'));
+    }
+    catch {
+        original = undefined;
+    }
+    const bundled = {
+        // One could argue that we should strip this down significantly.
+        // Theoretically though, a function may reach into it to get dependency versions
+        // and whatnot, so maybe it makes more sense to keep it as close to the original
+        // as possible?
+        ...original,
+        main: baseName, // This should never be the input file, always the built output name
+        type: 'module', // We explicitly create ESM output
+    };
+    const pkgJsonOutputPath = path.join(path.dirname(outputFilePath), 'package.json');
+    await writeFile(pkgJsonOutputPath, JSON.stringify(bundled, null, 2));
+}
+async function getBundleOutputPath(entryDir, fnName) {
+    const tmpPath = path.resolve(entryDir, '.build', `function-${fnName}`);
+    await rm(tmpPath, { recursive: true, force: true }).catch(logCleanupFailure);
+    await mkdir(tmpPath, { recursive: true });
+    return tmpPath;
+}
+/**
+ * Minor convenience/niceness to keep the same input filename, but change the extension
+ */
+function getOutputFilename(entryFileName) {
+    const baseName = path.basename(entryFileName, path.extname(entryFileName));
+    return baseName ? `${baseName}.js` : 'index.js';
+}
+function logCleanupFailure(err) {
+    console.warn(`[warn] Failed to clean up temporary files: ${err instanceof Error ? err.message : err}`);
+}