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

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

@@ -0,0 +1,306 @@
+import { spawn } from 'node:child_process';
+import { performance } from 'node:perf_hooks';
+import { cwd } from 'node:process';
+import { setTimeout } from 'node:timers';
+import { fileURLToPath } from 'node:url';
+import * as groq from 'groq-js';
+import config from '../../../config.js';
+import { groupBlueprintResources } from '../../blueprints/group-resources.js';
+import { isGroqContextOptions, } from '../../types.js';
+import { acquireFunctionBuild } from './prepare.js';
+function getChildProcessWrapperPath() {
+    return fileURLToPath(new URL('../child-process-wrapper.js', import.meta.url));
+}
+export function sanitizeLogs(logs) {
+    return logs.replace(/([a-zA-Z0-9]{10})[a-zA-Z0-9]{65,}/g, '$1**********');
+}
+export async function applyGroqRule(resource, payload, projectId, dataset) {
+    const { before, after, payload: data = null } = payload;
+    // If there is no rule set return everything
+    if (!resource.event)
+        return data;
+    // default groq rule is: gimme full doc content. otherwise, parse + eval custom rule
+    // applying the GROQ filter may result in a slimmer set of documents
+    if (resource.event.filter || resource.event.projection) {
+        const query = `*[${resource.event.filter || ''}]${resource.event.projection || ''}`;
+        try {
+            const rule = groq.parse(query, { mode: 'delta' });
+            const sanity = projectId && dataset ? { projectId, dataset } : undefined;
+            const queryResults = await groq.evaluate(rule, { dataset: [data], before, after, sanity });
+            const currentFunctionDocumentSet = await queryResults.get();
+            return currentFunctionDocumentSet[0];
+        }
+        catch (groqErr) {
+            const detail = groqErr instanceof Error && `; ${groqErr.message}`;
+            throw new Error(`Invalid rule configuration: ${query}${detail}`, { cause: groqErr });
+        }
+    }
+    // default groq rule so just return the data
+    return data;
+}
+export default async function invoke(resource, payload, context, options) {
+    if (!resource.src) {
+        throw new Error(`Function resource "${resource.name}" is missing the 'src' property.`);
+    }
+    const { forceColor = true, timeout = 10, onNestedInvoke, depth = 0, callStack = [] } = options;
+    // Apply the GROQ rule before preparing a build so a filtered-out event skips
+    // the (potentially expensive) transpile entirely.
+    let filteredData = payload?.payload?.data || {};
+    if (resource.type === 'sanity.function.document' ||
+        resource.type === 'sanity.function.media-library.asset') {
+        if (!isGroqContextOptions(context)) {
+            throw new Error('GROQ-based functions require a context with clientOptions');
+        }
+        const { projectId, dataset } = context.clientOptions;
+        if ('before' in payload) {
+            filteredData = await applyGroqRule(resource, payload, projectId, dataset);
+            if (typeof filteredData === 'undefined') {
+                return {
+                    logs: `⚠️ Filter "${resource.event?.filter}" returned an empty result. Skipping invoke.`,
+                    error: undefined,
+                    json: undefined,
+                };
+            }
+        }
+    }
+    // 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, context.blueprintFileDir);
+    let functionPath;
+    let bundleTimings;
+    try {
+        const prepared = await build.ready;
+        functionPath = prepared.functionPath;
+        bundleTimings = prepared.bundleTimings;
+    }
+    catch (err) {
+        await build.release();
+        throw err;
+    }
+    return new Promise((resolve, reject) => {
+        let child;
+        let timer;
+        let executionStart;
+        // The protocol is no longer one-shot: the child stays alive across nested
+        // `context.invoke` calls, so several handlers (result/exit/error/timeout)
+        // can race to settle this Promise. `settled` ensures exactly one wins and
+        // that shutdown/cleanup only runs once.
+        let settled = false;
+        // Timeout budget is paused while nested invokes run so a function's own
+        // time limit isn't consumed by the functions it calls.
+        let pendingNested = 0;
+        let timerStart = 0;
+        let remaining = timeout * 1000;
+        const nestedTimings = {};
+        // Output the child writes directly to its stdio pipes (anything that escapes
+        // the in-process console capture, e.g. a native crash). Hoisted to the
+        // Promise scope so both the timeout and exit handlers can surface it.
+        let stdout = '';
+        let stderr = '';
+        function startTimer() {
+            timerStart = performance.now();
+            timer = setTimeout(() => {
+                if (settled)
+                    return;
+                settled = true;
+                const executionTimeMs = performance.now() - executionStart;
+                shutdown();
+                // Resolve with error to retain all logs
+                resolve({
+                    json: undefined,
+                    logs: sanitizeLogs(stdout),
+                    error: {
+                        name: 'Error',
+                        message: `Timeout: Function exceeded the ${timeout}-second time limit.`,
+                        stack: '',
+                    },
+                    timings: {
+                        ...bundleTimings,
+                        ...nestedTimings,
+                        execute: executionTimeMs,
+                    },
+                });
+            }, Math.max(0, remaining));
+        }
+        function pauseTimer() {
+            if (pendingNested === 0) {
+                clearTimeout(timer);
+                remaining -= performance.now() - timerStart;
+            }
+            pendingNested += 1;
+        }
+        function resumeTimer() {
+            pendingNested -= 1;
+            if (pendingNested === 0 && !settled) {
+                startTimer();
+            }
+        }
+        // Resolve a nested `context.invoke(name, payload)` by re-entering the invoke
+        // pipeline via the supplied callback, then hand the result back to the child.
+        async function handleNestedInvoke(msg) {
+            const { id, name, payload: nestedPayload } = msg;
+            pauseTimer();
+            const nestedStart = performance.now();
+            try {
+                if (!onNestedInvoke) {
+                    throw new Error('Nested context.invoke is not supported in this context');
+                }
+                const nested = await onNestedInvoke(name, nestedPayload ?? {}, context, depth + 1, callStack);
+                nestedTimings[`invoke:${name}`] =
+                    (nestedTimings[`invoke:${name}`] ?? 0) + (performance.now() - nestedStart);
+                // Fire-and-forget contract: in production `context.invoke` returns once the
+                // message is enqueued (Lambda InvocationType:'Event', SNS/SQS), so a
+                // downstream handler error never reaches the caller. Mirror that here —
+                // the target ran (it was "dispatched"), so resolve the caller regardless
+                // of `nested.error`. The error isn't lost: it travels back in the returned
+                // result and is logged/streamed to the UI by the caller (app/test core).
+                if (child && !child.killed) {
+                    const response = {
+                        type: 'invoke-response',
+                        id,
+                        ok: true,
+                        result: { json: nested.json },
+                    };
+                    child.send(JSON.stringify(response));
+                }
+            }
+            catch (error) {
+                // The invoke could not be dispatched at all (unknown function, recursion
+                // guard, unsupported context). That is an enqueue-time failure, which in
+                // production rejects synchronously, so propagate it to the caller.
+                if (child && !child.killed) {
+                    const response = {
+                        type: 'invoke-response',
+                        id,
+                        ok: false,
+                        error: {
+                            message: error instanceof Error ? error.message : String(error),
+                            stack: error instanceof Error ? (error.stack ?? '') : '',
+                            name: error instanceof Error ? error.name : 'Error',
+                        },
+                    };
+                    child.send(JSON.stringify(response));
+                }
+            }
+            finally {
+                resumeTimer();
+            }
+        }
+        function start() {
+            executionStart = performance.now();
+            child = spawn('node', ['--enable-source-maps', getChildProcessWrapperPath()], {
+                cwd: cwd(),
+                stdio: ['pipe', 'pipe', 'pipe', 'ipc'], // changed: use 'pipe' so we can capture output
+                env: { ...process.env, ...resource.env, FORCE_COLOR: forceColor ? '1' : '0' },
+            });
+            child.stdout?.on('data', (data) => {
+                stdout += data.toString();
+            });
+            child.stderr?.on('data', (data) => {
+                stderr += data.toString();
+            });
+            child.on('message', (data) => {
+                let msg;
+                try {
+                    msg = JSON.parse(data.toString());
+                }
+                catch {
+                    return;
+                }
+                // Nested invoke request — handle without tearing down the child.
+                if (msg?.type === 'invoke-request') {
+                    handleNestedInvoke({ id: msg.id, name: msg.name, payload: msg.payload });
+                    return;
+                }
+                // Terminal result message.
+                if (settled)
+                    return;
+                settled = true;
+                const executionTimeMs = performance.now() - executionStart;
+                shutdown();
+                resolve({
+                    json: msg.json,
+                    logs: sanitizeLogs(msg.logs ?? ''),
+                    error: msg.error,
+                    timings: {
+                        ...bundleTimings,
+                        ...nestedTimings,
+                        execute: executionTimeMs,
+                    },
+                });
+            });
+            child.on('error', (error) => {
+                if (settled)
+                    return;
+                settled = true;
+                shutdown();
+                reject(new Error(`encountered error ${error.message}`));
+            });
+            // Resolve on 'close' to drain the pipes
+            child.on('close', (code) => {
+                if (settled)
+                    return;
+                settled = true;
+                const executionTimeMs = performance.now() - executionStart;
+                shutdown();
+                if (code !== 0) {
+                    // use captured stderr if available
+                    const message = stderr.trim().length > 0
+                        ? `Process failed with code ${code}\n${stderr}`
+                        : `exited with code ${code}`;
+                    // Resolve with error to retain all logs
+                    resolve({
+                        json: undefined,
+                        logs: sanitizeLogs(stdout),
+                        error: { name: 'Error', message, stack: '' },
+                        timings: {
+                            ...bundleTimings,
+                            ...nestedTimings,
+                            execute: executionTimeMs,
+                        },
+                    });
+                }
+                else {
+                    resolve({
+                        json: undefined,
+                        logs: sanitizeLogs(stdout),
+                        error: undefined,
+                        timings: {
+                            ...bundleTimings,
+                            ...nestedTimings,
+                            execute: executionTimeMs,
+                        },
+                    });
+                }
+            });
+            startTimer();
+            const payload = {
+                data: { ...filteredData },
+                context: {
+                    ...context,
+                    local: true,
+                    resources: groupBlueprintResources(context.resources ?? []),
+                    ...(isGroqContextOptions(context) && {
+                        clientOptions: {
+                            ...context.clientOptions,
+                            apiHost: config.apiUrl,
+                        },
+                    }),
+                },
+            };
+            const startMessage = { type: 'start', srcPath: functionPath, payload };
+            child.send(JSON.stringify(startMessage));
+        }
+        function shutdown() {
+            clearTimeout(timer);
+            if (child && !child.killed) {
+                child.kill();
+            }
+            // Release our reference to the shared build; its temp package.json and
+            // bundle are cleaned up once the last concurrent invoke releases.
+            build.release().catch((err) => console.warn('Build cleanup failed:', err));
+        }
+        start();
+    });
+}

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

@@ -0,0 +1,25 @@
+import type { FunctionResource, InvocationResponse, InvokeContextOptions, InvokeExecutionOptions, InvokePayloadOptions } from '../../types.js';
+/**
+ * Upper bound on nested `context.invoke` recursion, a backstop against invoke loops.
+ * Set to 16 to match Functions service lineage limit.
+ */
+export declare const MAX_INVOKE_DEPTH = 16;
+/**
+ * Guard a nested `context.invoke(name)` against runaway recursion and cycles.
+ * `depth` is the depth at which the target would run and `callStack` is the chain
+ * of function names already running (innermost last). Throws a descriptive error
+ * when the call must be rejected; returns normally when it is safe to proceed.
+ *
+ * This is an enqueue-time check: it runs before the target is dispatched, so the
+ * throw propagates to the caller's `context.invoke` (unlike a downstream handler
+ * error, which is fire-and-forget). See `handleNestedInvoke` in local.ts.
+ */
+export declare function assertNestedInvokeAllowed(name: string, depth: number, callStack: string[]): void;
+/**
+ * Execute a single already-resolved function in its own child process as one
+ * step of an invoke chain: enforce the depth/cycle guard, run it with the call
+ * stack extended by this function, and normalize timings.
+ */
+export declare function runFunction(resource: FunctionResource, payload: InvokePayloadOptions, context: InvokeContextOptions, options: InvokeExecutionOptions): Promise<InvocationResponse & {
+    timings: Record<string, number>;
+}>;

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

@@ -0,0 +1,41 @@
+import invoke from './local.js';
+/**
+ * Upper bound on nested `context.invoke` recursion, a backstop against invoke loops.
+ * Set to 16 to match Functions service lineage limit.
+ */
+export const MAX_INVOKE_DEPTH = 16;
+/**
+ * Guard a nested `context.invoke(name)` against runaway recursion and cycles.
+ * `depth` is the depth at which the target would run and `callStack` is the chain
+ * of function names already running (innermost last). Throws a descriptive error
+ * when the call must be rejected; returns normally when it is safe to proceed.
+ *
+ * This is an enqueue-time check: it runs before the target is dispatched, so the
+ * throw propagates to the caller's `context.invoke` (unlike a downstream handler
+ * error, which is fire-and-forget). See `handleNestedInvoke` in local.ts.
+ */
+export function assertNestedInvokeAllowed(name, depth, callStack) {
+    if (depth > MAX_INVOKE_DEPTH) {
+        throw new Error(`Maximum invoke depth (${MAX_INVOKE_DEPTH}) exceeded`);
+    }
+    if (callStack.includes(name)) {
+        throw new Error(`Invoke cycle detected: ${[...callStack, name].join(' → ')}`);
+    }
+}
+/**
+ * Execute a single already-resolved function in its own child process as one
+ * step of an invoke chain: enforce the depth/cycle guard, run it with the call
+ * stack extended by this function, and normalize timings.
+ */
+export async function runFunction(resource, payload, context, options) {
+    const { forceColor, timeout, depth = 0, callStack = [], onNestedInvoke } = options;
+    assertNestedInvokeAllowed(resource.name, depth, callStack);
+    const response = await invoke(resource, payload, context, {
+        forceColor,
+        timeout: timeout ?? resource.timeout,
+        onNestedInvoke,
+        depth,
+        callStack: [...callStack, resource.name],
+    });
+    return { ...response, timings: response.timings ?? {} };
+}

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

@@ -0,0 +1,20 @@
+import type { FunctionResource } from '../../types.js';
+/** Everything a child process needs to run a prepared function. */
+export interface PreparedFunction {
+    /** Absolute path to the entry file the child should import. */
+    functionPath: string;
+    /** Timings recorded while bundling, merged into the invocation result. */
+    bundleTimings?: Record<string, number>;
+}
+/** A reference-counted handle to a shared build. Call `release()` once per acquire. */
+export interface FunctionBuild {
+    ready: Promise<PreparedFunction>;
+    release: () => Promise<void>;
+}
+/**
+ * Acquire a shared, reference-counted build for `resource`. The first caller runs
+ * the transpile + temp package.json setup; concurrent callers reuse it. Every
+ * 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, blueprintFileDir: string): FunctionBuild;

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

@@ -0,0 +1,101 @@
+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';
+import { shouldAutoResolveDependencies } from '../should-auto-resolve-deps.js';
+import { shouldTranspileFunction } from '../should-transpile.js';
+import { transpileFunction } from '../transpile/function.js';
+/**
+ * In-progress builds keyed by function identity. Concurrent invokes of the same
+ * function (e.g. `Promise.all([context.invoke('f'), context.invoke('f')])`) share
+ * a single build and a single temp package.json, so they don't race on the
+ * deterministic per-function paths (`.build/function-<name>`, the temp
+ * package.json). The entry is removed once the last concurrent invoke releases
+ * it, so a later, non-overlapping invoke rebuilds and picks up source changes.
+ */
+const builds = new Map();
+function buildKey(resource) {
+    return `${resource.name}:${resource.src}`;
+}
+/**
+ * Acquire a shared, reference-counted build for `resource`. The first caller runs
+ * the transpile + temp package.json setup; concurrent callers reuse it. Every
+ * 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, blueprintFileDir) {
+    const key = buildKey(resource);
+    let entry = builds.get(key);
+    if (!entry) {
+        let cleanupBundle = async () => { };
+        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(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, 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(functionPath, resource.displayName ?? resource.name);
+            }
+            const shouldResolveDependencies = await shouldAutoResolveDependencies(resource);
+            if (shouldResolveDependencies && existingPackageJson) {
+                await resolveResourceDependencies({
+                    resource,
+                    functionPath: resolvedFunctionPath,
+                    blueprintFileDir,
+                    transpiled: shouldTranspile.transpile,
+                });
+            }
+            if (!existingPackageJson) {
+                createTempPackageJson(functionPath);
+                createdTempPackageJson = true;
+            }
+            return { functionPath, bundleTimings };
+        })();
+        entry = {
+            refs: 0,
+            ready,
+            teardown: async () => {
+                // rmSync is synchronous, so the temp package.json is gone before this
+                // function yields — a later invoke of the same function can't observe a
+                // half-removed state.
+                if (createdTempPackageJson) {
+                    cleanupTempPackageJson(functionPath);
+                }
+                await cleanupBundle().catch((err) => console.warn('Bundle cleanup failed:', err));
+            },
+        };
+        builds.set(key, entry);
+    }
+    const activeEntry = entry;
+    activeEntry.refs += 1;
+    let released = false;
+    const release = async () => {
+        if (released)
+            return;
+        released = true;
+        activeEntry.refs -= 1;
+        if (activeEntry.refs === 0) {
+            if (builds.get(key) === activeEntry)
+                builds.delete(key);
+            await activeEntry.teardown();
+        }
+    };
+    return { ready: activeEntry.ready, release };
+}

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>;