@sanity/runtime-cli 4.3.4 → 4.3.5-bundle.0

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

@@ -2,13 +2,13 @@
 import {EditorView, basicSetup, json} from '../vendor/vendor.bundle.js'
 import {ApiBaseElement} from './api-base.js'
 
-const template = `<div class="gutter-gradient relative h-100 max-h-100 y-scroll">
+const template = `<div class="gutter-gradient relative h-100 max-h-100 y-scroll border-top border-top-none-l">
     <div class="bg gutter-gradient sticky top-0 right-0 left-0 z-100">
       <div class="flex items-center space-between" style="padding: 8px 20px 8px 48px;">
       <h2 class="config-label mar-t-0 mar-b-0">Event</h2>
       <button ord="primary" class="sanity-button">
         <span>Run</span>
-  <svg data-sanity-icon="play" width="1em" height="1em" viewBox="0 0 25 25" fill="none" xmlns="http://www.w3.org/2000/svg"><path d="M7.5 18.5V6.5L17.5 12.5L7.5 18.5Z" fill="currentColor" stroke="currentColor" stroke-width="1.2" stroke-linejoin="round"></path></svg>
+        <svg data-sanity-icon="play" width="1em" height="1em" viewBox="0 0 25 25" fill="none" xmlns="http://www.w3.org/2000/svg"><path d="M7.5 18.5V6.5L17.5 12.5L7.5 18.5Z" fill="currentColor" stroke="currentColor" stroke-width="1.2" stroke-linejoin="round"></path></svg>
       </button>
   </div>
     <hr class='hr-border' style='margin-left: 31px; ' />
@@ -35,7 +35,8 @@ class PayloadPanel extends ApiBaseElement {
       this.button.innerHTML = '<network-spinner></network-spinner>'
     } else {
       this.button.removeAttribute('disabled')
-      this.button.innerText = 'Run'
+      this.button.innerHTML = `<span>Run</span>
+  <svg data-sanity-icon="play" width="1em" height="1em" viewBox="0 0 25 25" fill="none" xmlns="http://www.w3.org/2000/svg"><path d="M7.5 18.5V6.5L17.5 12.5L7.5 18.5Z" fill="currentColor" stroke="currentColor" stroke-width="1.2" stroke-linejoin="round"></path></svg>`
     }
   }
 

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

@@ -10,43 +10,35 @@ import {
 } from '../vendor/vendor.bundle.js'
 import {ApiBaseElement} from './api-base.js'
 
-const template = `<div class="gutter-gradient border-left h-100">
-    <m-tabs id="response-tabs" role="tablist">
-        <button class="tab" id="a" role="tab" aria-selected="true">Response</button>
-        <button class="tab" id="b" role="tab">Console</button>
-    </m-tabs>
-    <hr class="hr-border" style="margin-left: 31px" />
-    <div role="tabpanel" data-tab-id="a" class="h-100">
-        <div>
-            <span id="time"></span> <span id="size"></span>
+const template = `<div class="border-left border-top border-top-none-l h-100 gutter-gradient" style='height: 100%; max-height: 100%; overflow: hidden; display:grid;grid-template-rows: 50% 50%; grid-template-columns: 1fr;' >
+    <!-- Response Section -->
+        <div style='overflow-y:scroll;'>
+            <div style='padding-bottom: var(--space-6)'>
+            <h3 class="config-label" style='display: none; margin-top: 0;'>Response</h3>
+            <header class='flex space-between'>
+              <dl class='slab-stat'>
+                <dt style='white-space:nowrap;'>Response size</dt>
+                <dd id="size" style='white-space:nowrap;'></dd>
+              </dl>
+              <dl class='slab-stat'>
+                <dt>Time</dt>
+                <dd><time id="time" datetime=""></time></dd>
+              </dl>
+          </header>
+          <div id="response" name="response" class="cm-s-dracula"></div>
         </div>
-        <div id="response" name="response"></div>
+      </div>
+
+    <!-- Console Section -->
+    <div style='position: relative; border-top: 1px solid var(--card-border-color); background: var(--base-background-color); padding: var(--space-0) var(--space-3) var(--space-6) var(--space-4);overflow-y:scroll;'>
+        <h3 class="config-label" style="padding-top: var(--space-3); padding-bottom: var(--space-3);  z-index: 32; background: var(--base-background-color); position: sticky; top: 0; left: 0; right: 0; margin-top:0;margin-bottom:0;">Console</h3>
+        <pre style="padding: 0; margin: 0; white-space: pre-wrap; word-wrap: break-word;"></pre>
     </div>
-    <div role="tabpanel" data-tab-id="b" class="pad-t-sm h-100" hidden><pre></pre></div>
 </div>
 `
 class ResponsePanel extends ApiBaseElement {
-  switchTab = (e) => {
-    const tabElement = e.target.closest('[role=tab]')
-    // If the click wasn't on a tab button, do nothing
-    if (!tabElement) {
-      return
-    }
-    const selectedTabId = tabElement.id
-
-    // Select the tab and its panel
-    // Use e.currentTarget which refers to the element the listener was attached to (m-tabs)
-    for (const tab of e.currentTarget.querySelectorAll('[role=tab]')) {
-      tab.ariaSelected = tab.id === selectedTabId
-    }
-
-    // Find panels relative to the component itself to avoid affecting other potential tab panels on the page
-    for (const panel of this.querySelectorAll('[role=tabpanel]')) {
-      panel.hidden = panel.dataset.tabId !== selectedTabId
-    }
-  }
   updateResponse = ({result}) => {
-    const {error, json, logs, time} = result
+    const {error, json, logs, time, timings} = result
     if (!error) {
       const transaction = this.api.store.response.state.update({
         changes: {
@@ -58,7 +50,20 @@ class ResponsePanel extends ApiBaseElement {
       this.api.store.response.dispatch(transaction)
 
       this.size.innerText = json ? prettyBytes(JSON.stringify(json).length) : ''
-      this.time.innerText = prettyMilliseconds(time)
+
+      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`
+      }
+
       this.consoleTab.innerText = logs
     } else {
       this.consoleTab.innerText = error?.details?.error
@@ -71,8 +76,6 @@ class ResponsePanel extends ApiBaseElement {
     this.size = this.querySelector('#size')
     this.time = this.querySelector('#time')
     this.consoleTab = this.querySelector('pre')
-    this.tabs = this.querySelector('m-tabs')
-    this.tabs.addEventListener('click', this.switchTab)
     this.api.subscribe(this.updateResponse, ['result'])
 
     this.api.store.response = new EditorView({
@@ -83,7 +86,6 @@ class ResponsePanel extends ApiBaseElement {
   }
 
   disconnectedCallback() {
-    this.tabs.removeEventListener('click', this.switchTab)
     this.api.unsubscribe(this.updateResponse)
   }
 }

package/dist/server/static/index.html

@@ -1,9 +1,11 @@
 <!DOCTYPE html>
 <html>
     <head>
+        <meta charset="UTF-8">
         <link href="https://unpkg.com/m-@3.2.0/dist/m-.woff2" rel="preload" as="font" crossorigin>
-        <link href="./components/app.css" rel="stylesheet">
         <link href="https://unpkg.com/m-@3.2.0/dist/m-.css" rel="stylesheet">
+        <link href="./components/app.css" rel="stylesheet">
+
     </head>
     <body>
         <header data-slot="header">
@@ -16,10 +18,10 @@
         </header>
         <filters-component></filters-component>
         <nav style="padding-top: var(--size-5); border-right: 1px solid var(--card-border-color);max-height: 100%; overflow-y: scroll;">
-          <h4 class="config-label mar-t-0" style="padding-left: 12px;">Functions</h4>
+          <h4 class="config-label mar-t-0" style="padding-left: var(--space-3); margin-bottom:var(--space-3);">Functions</h4>
           <function-list></function-list>
         </nav>
-        <main style='display: grid; grid-template-columns: 1fr 1fr;grid-template-rows: 1fr;'>
+        <main style='display: grid; grid-template-columns: 1fr 1fr;grid-template-rows: 1fr;max-height: 100%;overflow:hidden;'>
               <payload-panel></payload-panel>
               <response-panel></response-panel>
         </main>

package/dist/server/static/vendor/vendor.bundle.d.ts

@@ -1018,9 +1018,9 @@ declare class ViewState {
     viewport: Viewport | undefined;
     lineGaps: any[];
     lineGapDeco: any;
-    updateForViewport(): 0 | 2;
+    updateForViewport(): 2 | 0;
     viewports: (Viewport | undefined)[] | undefined;
-    updateScaler(): 0 | 2;
+    updateScaler(): 2 | 0;
     updateViewportLines(): void;
     viewportLines: any[] | undefined;
     update(update: any, scrollTarget?: null): void;

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}`);
+}

package/dist/utils/bundle/cleanup-source-maps.d.ts

@@ -0,0 +1,10 @@
+/**
+ * "Clean up" source maps by removing absolute paths and making paths relative to the
+ * _input_ (eg source) rather than the _output_ (eg bundle) directory. Note that this
+ * process is not critical since the source content is inlined, but it helps with
+ * debugging to have (approximate) paths to the original source files.
+ *
+ * @param inputDir - The directory where the source files are located
+ * @param outputDir - The directory where the bundled files are located
+ */
+export declare function cleanupSourceMaps(inputDir: string, outputDir: string): Promise<void>;

package/dist/utils/bundle/cleanup-source-maps.js

@@ -0,0 +1,53 @@
+import { promises as fs } from 'node:fs';
+import { isAbsolute, join, relative } from 'node:path';
+/**
+ * "Clean up" source maps by removing absolute paths and making paths relative to the
+ * _input_ (eg source) rather than the _output_ (eg bundle) directory. Note that this
+ * process is not critical since the source content is inlined, but it helps with
+ * debugging to have (approximate) paths to the original source files.
+ *
+ * @param inputDir - The directory where the source files are located
+ * @param outputDir - The directory where the bundled files are located
+ */
+export async function cleanupSourceMaps(inputDir, outputDir) {
+    const entries = await fs.readdir(outputDir, { withFileTypes: true });
+    const sourceMaps = entries.filter((entry) => entry.isFile() && entry.name.endsWith('.map'));
+    for (const entry of sourceMaps) {
+        const filePath = join(outputDir, entry.name);
+        let raw;
+        try {
+            raw = await fs.readFile(filePath, 'utf8');
+        }
+        catch {
+            return;
+        }
+        let map;
+        try {
+            const json = JSON.parse(raw);
+            map = isRelevantSourceMap(json) ? json : undefined;
+        }
+        catch {
+            return;
+        }
+        if (!map) {
+            return;
+        }
+        map.sources = map.sources.map((source) => {
+            const fullPath = isAbsolute(source) ? source : join(outputDir, source);
+            return relative(inputDir, fullPath);
+        });
+        try {
+            await fs.writeFile(filePath, JSON.stringify(map));
+        }
+        catch {
+            // ignore write errors
+        }
+    }
+}
+function isRelevantSourceMap(map) {
+    return (typeof map === 'object' &&
+        map !== null &&
+        'sources' in map &&
+        Array.isArray(map.sources) &&
+        map.sources.every((source) => typeof source === 'string'));
+}

package/dist/utils/bundle/find-up.d.ts

@@ -0,0 +1,16 @@
+/**
+ * Walks up the directory tree from a starting point to find a given file/directory.
+ *
+ * @param fileName - The name of the file/directory to find.
+ * @param startDir - The directory to start searching from (default is the current working directory).
+ * @returns The path to the file if found, otherwise undefined.
+ */
+export declare function findUp(fileName: string, startDir?: string): Promise<string | undefined>;
+/**
+ * Finds the directory containing a specific file/directory by walking up the directory tree.
+ *
+ * @param fileName - The name of the file/directory to find.
+ * @param startDir - The directory to start searching from (default is the current working directory).
+ * @returns The directory containing the file if found, otherwise undefined.
+ */
+export declare function findDirUp(fileName: string, startDir?: string): Promise<string | undefined>;

package/dist/utils/bundle/find-up.js

@@ -0,0 +1,39 @@
+import { access } from 'node:fs/promises';
+import path from 'node:path';
+/**
+ * Walks up the directory tree from a starting point to find a given file/directory.
+ *
+ * @param fileName - The name of the file/directory to find.
+ * @param startDir - The directory to start searching from (default is the current working directory).
+ * @returns The path to the file if found, otherwise undefined.
+ */
+export async function findUp(fileName, startDir = process.cwd()) {
+    let dir = path.resolve(startDir);
+    while (true) {
+        const candidate = path.join(dir, fileName);
+        try {
+            await access(candidate);
+            return candidate;
+        }
+        catch {
+            const parent = path.dirname(dir);
+            if (parent === dir)
+                break; // Reached root
+            dir = parent;
+        }
+    }
+    return undefined;
+}
+/**
+ * Finds the directory containing a specific file/directory by walking up the directory tree.
+ *
+ * @param fileName - The name of the file/directory to find.
+ * @param startDir - The directory to start searching from (default is the current working directory).
+ * @returns The directory containing the file if found, otherwise undefined.
+ */
+export async function findDirUp(fileName, startDir = process.cwd()) {
+    const filePath = await findUp(fileName, startDir);
+    if (!filePath)
+        return undefined;
+    return path.dirname(filePath);
+}

package/dist/utils/bundle/verify-handler.d.ts

@@ -0,0 +1,2 @@
+import type { build } from 'vite';
+export declare function verifyHandler(result: Awaited<ReturnType<typeof build>>): Promise<void>;

package/dist/utils/bundle/verify-handler.js

@@ -0,0 +1,13 @@
+export async function verifyHandler(result) {
+    if ('close' in result) {
+        throw new Error('Incorrect build output, got watcher');
+    }
+    const outputs = (Array.isArray(result) ? result : [result]).flatMap(({ output }) => output);
+    const bundledIndex = outputs.find((output) => output.type === 'chunk' && output.isEntry && output.name === 'index');
+    if (!bundledIndex || bundledIndex.type !== 'chunk') {
+        throw new Error('Unexpected build output, no bundled index found');
+    }
+    if (!bundledIndex.exports.includes('handler')) {
+        throw new Error('Unexpected build output, no `handler` export found');
+    }
+}

package/dist/utils/child-process-wrapper.js

@@ -1,16 +1,18 @@
 import {existsSync, statSync} from 'node:fs'
-import {join} from 'node:path'
+import {isAbsolute, join} from 'node:path'
 import process from 'node:process'
 
 export function getFunctionSource(src) {
-  if (statSync(src).isDirectory()) {
-    const indexPath = join(src, 'index.js')
+  const pathToCheck = isAbsolute(src) ? src : join(process.cwd(), src)
+
+  if (statSync(pathToCheck).isDirectory()) {
+    const indexPath = join(pathToCheck, 'index.js')
     if (!existsSync(indexPath)) {
-      throw Error(`Function directory ${src} has no index.js`)
+      throw Error(`Function directory ${pathToCheck} has no index.js`)
     }
     return indexPath
   }
-  return src
+  return pathToCheck
 }
 
 // Start when payload data arrives from parent process
@@ -28,7 +30,7 @@ process.on('message', async (data) => {
   let json = null
 
   // Import the function code
-  const {handler} = await import(getFunctionSource(join(process.cwd(), srcPath)))
+  const {handler} = await import(getFunctionSource(srcPath))
 
   // backup stdout
   const originalStdoutWrite = process.stdout.write.bind(process.stdout)

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

@@ -0,0 +1,11 @@
+/**
+ * Resolves the source path to an executable entry file path.
+ *
+ * If the source path is a directory, it looks for `package.json#main`, then `index.ts`, then `index.js`.
+ *
+ * @param srcPath - The source path (can be a file or directory).
+ * @param displayName - Optional display name for the function, used in error messages.
+ * @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>;

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

@@ -0,0 +1,75 @@
+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.
+ *
+ * If the source path is a directory, it looks for `package.json#main`, then `index.ts`, then `index.js`.
+ *
+ * @param srcPath - The source path (can be a file or directory).
+ * @param displayName - Optional display name for the function, used in error messages.
+ * @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);
+    let stats;
+    try {
+        stats = await stat(absolutePath);
+    }
+    catch (err) {
+        throw new Error(`Source path not found or inaccessible: ${srcPath}`, { cause: err });
+    }
+    if (stats.isFile()) {
+        // It's already an entry file path
+        return absolutePath;
+    }
+    if (stats.isDirectory()) {
+        // 1. Check package.json#main
+        try {
+            const pkgJsonPath = join(absolutePath, 'package.json');
+            const pkgJsonContent = await readFile(pkgJsonPath, 'utf8');
+            const pkgJson = JSON.parse(pkgJsonContent);
+            if (pkgJson.main) {
+                const mainPath = resolve(absolutePath, pkgJson.main);
+                if (await fileExists(mainPath)) {
+                    return mainPath;
+                }
+                // If pkgJson.main points to a non-existent file, we continue checking index files
+            }
+        }
+        catch {
+            // Ignore errors (missing package.json, invalid JSON, etc.)
+            // Consider warning the user on invalid JSON though?
+        }
+        // 2. Check index.ts
+        const indexTs = join(absolutePath, 'index.ts');
+        if (await fileExists(indexTs)) {
+            return indexTs;
+        }
+        // 3. Check index.js
+        const indexJs = join(absolutePath, '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.`);
+    }
+    // Should not happen if stat succeeded, but defensively handle
+    throw new Error(`Source path is neither a file nor a directory: ${srcPath}`);
+}
+/**
+ * Checks if a file exists and is a file.
+ */
+async function fileExists(filePath) {
+    try {
+        const stats = await stat(filePath);
+        return stats.isFile();
+    }
+    catch (err) {
+        if (err instanceof Error && 'code' in err && err.code === 'ENOENT') {
+            return false;
+        }
+        throw err; // Re-throw other errors
+    }
+}

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

@@ -0,0 +1,2 @@
+import type { LocalFunctionResource } from '../types.js';
+export declare function shouldBundleFunction(resource: LocalFunctionResource): Promise<boolean>;

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

@@ -0,0 +1,23 @@
+import { findFunctionEntryPoint } from './find-entry-point.js';
+export async function shouldBundleFunction(resource) {
+    // 1. Explicit configuration takes precedence
+    if (typeof resource.bundle === 'boolean') {
+        return resource.bundle;
+    }
+    if (!resource.src) {
+        // Cannot determine without a source path
+        return false;
+    }
+    try {
+        // 2. Find the actual entry point
+        const entryPoint = await findFunctionEntryPoint(resource.src, resource.displayName ?? resource.name);
+        // 3. Check if the resolved entry point is a TypeScript file
+        return 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 bundling is needed: ${err instanceof Error ? err.message : err}`);
+        return false;
+    }
+}

package/dist/utils/invoke-local.d.ts

@@ -1,3 +1,3 @@
-import type { InvocationResponse, InvokeContextOptions } from './types.js';
+import type { InvocationResponse, InvokeContextOptions, LocalFunctionResource } from './types.js';
 export declare function sanitizeLogs(logs: string): string;
-export default function invoke(srcPath: string, data: null | object, context: InvokeContextOptions, timeout?: number): Promise<InvocationResponse>;
+export default function invoke(resource: LocalFunctionResource, data: Record<string, unknown> | null, context: InvokeContextOptions, timeout?: number): Promise<InvocationResponse>;