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

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

@@ -1,9 +1,13 @@
-import {table as renderTable} from 'node:console'
 import {existsSync, statSync} from 'node:fs'
 import {isAbsolute, join} from 'node:path'
 import process from 'node:process'
 import {pathToFileURL} from 'node:url'
-import {inspect} from 'node:util'
+import {installConsole} from './child-runtime/console.js'
+import {createInvoker} from './child-runtime/invoke.js'
+import {createResourcesApi} from './child-runtime/resources.js'
+
+installConsole()
+const invoker = createInvoker()
 
 export function getFunctionSource(src) {
   const pathToCheck = isAbsolute(src) ? src : join(process.cwd(), src)
@@ -18,91 +22,6 @@ export function getFunctionSource(src) {
   return pathToFileURL(pathToCheck).href
 }
 
-// Monkey patch console menthods to have logs match server log format
-function logPrefix(level, ...args) {
-  const date = new Date()
-  const shouldUseColors = process.env.FORCE_COLOR === '1'
-  const message = args
-    .map((arg) =>
-      typeof arg === 'string' ? arg : inspect(arg, {depth: null, colors: shouldUseColors}),
-    )
-    .join(' ')
-  return `${date.toLocaleDateString()} ${date.toLocaleTimeString()} ${level.toUpperCase()} ${message}`
-}
-
-console.log = (...args) => {
-  process.stdout.write(`${logPrefix('info', ...args)}\n`)
-}
-
-console.info = (...args) => {
-  process.stdout.write(`${logPrefix('info', ...args)}\n`)
-}
-
-console.dir = (obj, options) => {
-  const shouldUseColors = process.env.FORCE_COLOR === '1'
-  const inspectOptions = {...options, colors: shouldUseColors}
-  process.stdout.write(`${logPrefix('info', inspect(obj, inspectOptions))}\n`)
-}
-
-console.table = (data, columns) => {
-  const prefix = logPrefix('info')
-
-  // Capture table output
-  const originalWrite = process.stdout.write.bind(process.stdout)
-  let buffer = ''
-
-  process.stdout.write = (chunk, _encoding, callback) => {
-    buffer += chunk
-    if (typeof callback === 'function') callback()
-  }
-
-  renderTable(data, columns)
-
-  // Restore and print
-  process.stdout.write = originalWrite
-  for (const line of buffer.split('\n')) {
-    if (line.trim()) {
-      const message = `${!line.startsWith(prefix) ? `${prefix} ${line}` : line}`.trim()
-      process.stdout.write(`${message}\n`)
-    }
-  }
-}
-
-console.warn = (...args) => {
-  process.stdout.write(`${logPrefix('warn', ...args)}\n`)
-}
-
-console.error = (...args) => {
-  process.stdout.write(`${logPrefix('error', ...args)}\n`)
-}
-
-/**
- * Pending nested `context.invoke` calls, keyed by correlation id. Each entry
- * holds the resolve/reject of the Promise returned to the user's handler; it is
- * settled when the matching `invoke-response` arrives from the parent.
- * @type {Map<string, {resolve: (value: unknown) => void, reject: (reason: Error) => void}>}
- */
-const pendingInvokes = new Map()
-let invokeSeq = 0
-
-/**
- * `context.invoke(name, payload)` — ask the parent to execute another blueprint
- * function and resolve with its return value. Sent over IPC and correlated by id.
- * @param {string} name
- * @param {Record<string, unknown>} [payload]
- * @returns {Promise<unknown>}
- */
-function invokeFunction(name, payload = {}) {
-  if (typeof name !== 'string' || name.length === 0) {
-    return Promise.reject(new Error('context.invoke requires a function name'))
-  }
-  const id = String(++invokeSeq)
-  return new Promise((resolve, reject) => {
-    pendingInvokes.set(id, {resolve, reject})
-    process.send(JSON.stringify({type: 'invoke-request', id, name, payload}))
-  })
-}
-
 // Listen for IPC messages from the parent process.
 process.on('message', async (data) => {
   let jsonData = null
@@ -115,18 +34,7 @@ process.on('message', async (data) => {
 
   // Response to a nested context.invoke() — route to the awaiting Promise and stop.
   if (jsonData?.type === 'invoke-response') {
-    const pending = pendingInvokes.get(jsonData.id)
-    if (!pending) return
-    pendingInvokes.delete(jsonData.id)
-    if (jsonData.ok) {
-      pending.resolve(jsonData.result?.json)
-    } else {
-      const {message, stack, name} = jsonData.error ?? {}
-      const error = new Error(message ?? 'Nested invoke failed')
-      if (stack) error.stack = stack
-      if (name) error.name = name
-      pending.reject(error)
-    }
+    invoker.handleResponse(jsonData)
     return
   }
 
@@ -160,25 +68,20 @@ process.on('message', async (data) => {
   try {
     // Import the function code
     const entry = await import(getFunctionSource(srcPath))
-    const eventHandler = entry.handler || entry.default
-
-    if (typeof eventHandler !== 'function') {
-      throw new Error(
-        'No valid handler found. Please provide a default export or a named export, "handler"',
-      )
+    const handler = entry.handler || entry.default
+    if (typeof handler !== 'function') {
+      throw new Error('No valid handler found. Provide a default export or a named "handler".')
     }
 
     // Replace resources JSON with Resources API
     context.resources = createResourcesApi(context.resources)
 
     // Allow the handler to invoke other blueprint functions by name.
-    context.invoke = invokeFunction
-
-    json = await eventHandler({
+    context.invoke = invoker.invoke
+    json = await handler({
       context,
       event,
-      // mock sync-tag-invalidate done callback
-      done: async (_tags) => new Response(null, {status: 204}),
+      done: async () => new Response(null, {status: 204}),
     })
 
     // Restore streams
@@ -191,7 +94,6 @@ process.on('message', async (data) => {
     // Restore streams on error
     process.stdout.write = originalStdoutWrite
     process.stderr.write = originalStderrWrite
-
     const errorInfo = {
       type: 'result',
       json: null,
@@ -207,63 +109,3 @@ process.on('message', async (data) => {
     process.exit(1)
   }
 })
-
-/**
- * The returned proxy wraps a function so the API itself is callable.
- * @param {Record<string, ResourceEntry[]>} resources
- * @returns {ResourcesApi}
- */
-export function createResourcesApi(resources) {
-  const findByName = (name) => {
-    for (const group of Object.values(resources)) {
-      const found = group.find((r) => r.name === name)
-      if (found) return found
-    }
-    return undefined
-  }
-  let allCache
-  const all = () => (allCache ??= Object.values(resources).flat())
-
-  return /** @type {ResourcesApi} */ (
-    /** @type {unknown} */ (
-      /*
-       * The Proxy target is `findByName`, so invoking the API as a function —
-       * `context.resources('my-proj')` — bypasses the `get` trap entirely and
-       * calls `findByName` directly for a cross-type lookup by name.
-       */
-      new Proxy(findByName, {
-        get: (_target, prop) => {
-          // context.resources.all() — flat array of every resource across types
-          if (prop === 'all') return all
-          // [...context.resources] / for (const r of context.resources) — iterate all
-          if (prop === Symbol.iterator) {
-            return function* () {
-              yield* all()
-            }
-          }
-
-          /**
-           * Symbol property access (other than iterator above) and `then`
-           * lookups return undefined. The `then` guard prevents the API from
-           * looking like a thenable, so `await context.resources` resolves to
-           * the proxy itself rather than hanging or unwrapping unexpectedly.
-           */
-          if (typeof prop !== 'string' || prop === 'then') {
-            return undefined
-          }
-
-          /**
-           * context.resources.<type>(name) — per-type lookup,
-           * e.g. context.resources.project('my-proj').
-           * Returns a function so the caller supplies the name;
-           * unknown types yield a function that always returns undefined.
-           */
-          return (/** @type {string} */ name) =>
-            Object.hasOwn(resources, prop)
-              ? resources[prop].find((r) => r.name === name)
-              : undefined
-        },
-      })
-    )
-  )
-}

package/dist/utils/functions/child-runtime/console.d.ts

@@ -0,0 +1 @@
+export function installConsole(): void

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

@@ -0,0 +1,50 @@
+import {table as renderTable} from 'node:console'
+import process from 'node:process'
+import {inspect} from 'node:util'
+
+// Monkey patch console methods to have logs match server log format
+function logPrefix(level, ...args) {
+  const date = new Date()
+  const shouldUseColors = process.env.FORCE_COLOR === '1'
+  const message = args
+    .map((arg) =>
+      typeof arg === 'string' ? arg : inspect(arg, {depth: null, colors: shouldUseColors}),
+    )
+    .join(' ')
+  return `${date.toLocaleDateString()} ${date.toLocaleTimeString()} ${level.toUpperCase()} ${message}`
+}
+
+export function installConsole() {
+  console.log = (...args) => process.stdout.write(`${logPrefix('info', ...args)}\n`)
+  console.info = (...args) => process.stdout.write(`${logPrefix('info', ...args)}\n`)
+  console.warn = (...args) => process.stdout.write(`${logPrefix('warn', ...args)}\n`)
+  console.error = (...args) => process.stdout.write(`${logPrefix('error', ...args)}\n`)
+  console.dir = (obj, options) => {
+    const shouldUseColors = process.env.FORCE_COLOR === '1'
+    const inspectOptions = {...options, colors: shouldUseColors}
+    process.stdout.write(`${logPrefix('info', inspect(obj, inspectOptions))}\n`)
+  }
+  console.table = (data, columns) => {
+    const prefix = logPrefix('info')
+
+    // Capture table output
+    const originalWrite = process.stdout.write.bind(process.stdout)
+    let buffer = ''
+
+    process.stdout.write = (chunk, _encoding, callback) => {
+      buffer += chunk
+      if (typeof callback === 'function') callback()
+    }
+
+    renderTable(data, columns)
+
+    // Restore and print
+    process.stdout.write = originalWrite
+    for (const line of buffer.split('\n')) {
+      if (line.trim()) {
+        const message = `${!line.startsWith(prefix) ? `${prefix} ${line}` : line}`.trim()
+        process.stdout.write(`${message}\n`)
+      }
+    }
+  }
+}

package/dist/utils/functions/child-runtime/invoke.d.ts

@@ -0,0 +1,4 @@
+export function createInvoker(): {
+  invoke: (name: string, payload?: Record<string, unknown>) => Promise<unknown>
+  handleResponse: (msg: unknown) => void
+}

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

@@ -0,0 +1,47 @@
+import process from 'node:process'
+
+export function createInvoker() {
+  /**
+   * Pending nested `context.invoke` calls, keyed by correlation id. Each entry
+   * holds the resolve/reject of the Promise returned to the user's handler; it is
+   * settled when the matching `invoke-response` arrives from the parent.
+   * @type {Map<string, {resolve: (value: unknown) => void, reject: (reason: Error) => void}>}
+   */
+  const pending = new Map()
+  let invokeSeq = 0
+
+  /**
+   * `context.invoke(name, payload)` — ask the parent to execute another blueprint
+   * function and resolve with its return value. Sent over IPC and correlated by id.
+   * @param {string} name
+   * @param {Record<string, unknown>} [payload]
+   * @returns {Promise<unknown>}
+   */
+  function invoke(name, payload = {}) {
+    if (typeof name !== 'string' || name.length === 0) {
+      return Promise.reject(new Error('context.invoke requires a function name'))
+    }
+    const id = String(++invokeSeq)
+    return new Promise((resolve, reject) => {
+      pending.set(id, {resolve, reject})
+      process.send(JSON.stringify({type: 'invoke-request', id, name, payload}))
+    })
+  }
+
+  function handleResponse(msg) {
+    const pendingEntry = pending.get(msg.id)
+    if (!pendingEntry) return
+    pending.delete(msg.id)
+    if (msg.ok) {
+      pendingEntry.resolve(msg.result?.json)
+    } else {
+      const {message, stack, name} = msg.error ?? {}
+      const err = new Error(message ?? 'Nested invoke failed')
+      if (stack) err.stack = stack
+      if (name) err.name = name
+      pendingEntry.reject(err)
+    }
+  }
+
+  return {invoke, handleResponse}
+}

package/dist/utils/functions/child-runtime/resources.d.ts

@@ -0,0 +1,4 @@
+import type {ResourcesApi} from '@sanity/functions'
+import type {GroupedBlueprintResources} from '../../blueprints/group-resources.js'
+
+export function createResourcesApi(resources: GroupedBlueprintResources): ResourcesApi

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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