@sanity/runtime-cli 17.16.0 → 17.17.0

package/dist/utils/blueprints/group-resources.js

@@ -8,7 +8,8 @@ const BLUEPRINT_TYPE_TO_KEY = {
 };
 export function groupBlueprintResources(blueprintResources) {
     const grouped = {};
-    for (const resource of blueprintResources) {
+    for (const resolvedResource of blueprintResources) {
+        const resource = resolvedResource.resource;
         if (resource.type === 'sanity.access.robot')
             continue;
         const key = (resource.type?.startsWith('sanity.function.')
@@ -18,9 +19,8 @@ export function groupBlueprintResources(blueprintResources) {
             continue;
         if (!grouped[key])
             grouped[key] = [];
-        const externalId = resource.externalId;
         grouped[key].push({
-            id: externalId || 'not-deployed',
+            id: resolvedResource.externalId || 'not-deployed',
             name: resource.name,
             type: resource.type,
         });

package/dist/utils/blueprints/resolve-deployed-resources.d.ts

@@ -1,5 +1,5 @@
 import type { BlueprintResource } from '@sanity/blueprints';
-import type { AuthParams } from '../types.js';
+import type { AuthParams, ResolvedResource } from '../types.js';
 interface ResolveOptions {
     resources: BlueprintResource[];
     stackId?: string;
@@ -12,5 +12,5 @@ interface ResolveOptions {
  * resources that aren't yet deployed are preserved without an externalId.
  * Any failure to fetch the stack falls back to the raw local resources.
  */
-export declare function resolveDeployedResources({ resources, stackId, auth, fetchFn, }: ResolveOptions): Promise<BlueprintResource[]>;
+export declare function resolveDeployedResources({ resources, stackId, auth, fetchFn, }: ResolveOptions): Promise<ResolvedResource<BlueprintResource>[]>;
 export {};

package/dist/utils/blueprints/resolve-deployed-resources.js

@@ -7,11 +7,11 @@ import { getStack } from '../../actions/blueprints/stacks.js';
  */
 export async function resolveDeployedResources({ resources, stackId, auth, fetchFn, }) {
     if (!stackId || !auth?.token || !auth.scopeType || !auth.scopeId)
-        return resources;
+        return resources.map((r) => ({ resource: r }));
     try {
         const response = await getStack({ stackId, auth, fetchFn });
         if (!response.ok || !Array.isArray(response.stack?.resources))
-            return resources;
+            return resources.map((r) => ({ resource: r }));
         const deployedByKey = new Map();
         for (const deployed of response.stack.resources) {
             if (deployed.externalId) {
@@ -20,10 +20,10 @@ export async function resolveDeployedResources({ resources, stackId, auth, fetch
         }
         return resources.map((resource) => {
             const externalId = deployedByKey.get(`${resource.type}:${resource.name}`);
-            return externalId ? { ...resource, externalId } : resource;
+            return { resource, externalId };
         });
     }
     catch {
-        return resources;
+        return resources.map((r) => ({ resource: r }));
     }
 }

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

@@ -1,7 +1,7 @@
 import type { BlueprintApplicationResource, BlueprintInstallationConfigResource, BlueprintStudioResource } from '@sanity/blueprints';
 import { type BuildStudioEventListener } from '@sanity/cli-build/_internal/build';
 import type { Output } from '@sanity/cli-core';
-import type { AssetPrepResult } from '../types.js';
+import type { AssetPrepResult, ResolvedResource } from '../types.js';
 export type BundleResource = BlueprintStudioResource | BlueprintApplicationResource | BlueprintInstallationConfigResource;
 type BuildContext<R extends BundleResource> = {
     resource: R;
@@ -28,9 +28,9 @@ export declare const BUNDLE_SPECS: {
         build: typeof buildInstallationConfigBundle;
     };
 };
-export declare function prepareBundleAsset<R extends BundleResource>({ blueprintFileDir, resource, }: {
+export declare function prepareBundleAsset<R extends BundleResource>({ blueprintFileDir, resolvedResource, }: {
     blueprintFileDir: string;
-    resource: R;
+    resolvedResource: ResolvedResource<R>;
 }): Promise<AssetPrepResult>;
 declare function buildStudioBundle({ resource, appId, workDir, outDir, output, eventListener, }: BuildContext<BlueprintStudioResource>): Promise<BuildResult>;
 declare function buildApplicationBundle({ resource, appId, workDir, outDir, output, eventListener, }: BuildContext<BlueprintApplicationResource>): Promise<BuildResult>;

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

@@ -5,6 +5,7 @@ import path, { basename, dirname, join } from 'node:path';
 import { pipeline } from 'node:stream/promises';
 import { createGzip } from 'node:zlib';
 import { buildApp, buildStudio, compareDependencyVersions, } from '@sanity/cli-build/_internal/build';
+import { buildStudioSchemasAndManifests } from '@sanity/cli-build/_internal/extract';
 import { getLocalPackageVersion } from '@sanity/cli-core';
 import { pack } from 'tar-fs';
 export const BUNDLE_SPECS = {
@@ -12,10 +13,11 @@ export const BUNDLE_SPECS = {
     'sanity.application': { requiresAppId: true, build: buildApplicationBundle },
     'sanity.installation.config': { requiresAppId: false, build: buildInstallationConfigBundle },
 };
-export async function prepareBundleAsset({ blueprintFileDir, resource, }) {
+export async function prepareBundleAsset({ blueprintFileDir, resolvedResource, }) {
+    const resource = resolvedResource.resource;
     // The lookup can't prove it yields the spec matching this R, so it's asserted once here.
     const spec = BUNDLE_SPECS[resource.type];
-    const appId = getAppId(resource);
+    const appId = getAppId(resolvedResource);
     if (spec.requiresAppId && !appId) {
         return {
             success: false,
@@ -104,8 +106,15 @@ export async function prepareBundleAsset({ blueprintFileDir, resource, }) {
     }
 }
 async function buildStudioBundle({ resource, appId, workDir, outDir, output, eventListener, }) {
+    // this has been checked before we got here but this helps the type checker
+    if (!appId)
+        throw new Error(`Unable to determine appId for ${resource.type} resource '${resource.name}'`);
+    // currently we only support hard-coded project, support for dynamic project id to be added
+    const projectId = resource.project;
+    if (!projectId || projectId.startsWith('$.'))
+        throw new Error(`Unable to determine project for ${resource.type} resource '${resource.name}'`);
     let mismatchedPackages;
-    await buildStudio({
+    const { mfManifest } = await buildStudio({
         appId,
         autoUpdatesEnabled: resource.autoUpdates.enabled,
         checkAppId() { },
@@ -117,10 +126,12 @@ async function buildStudioBundle({ resource, appId, workDir, outDir, output, eve
         determineBasePath() {
             return resource.basePath ?? '/';
         },
-        // a studio is a standalone app, not a workbench module-federation app
         isApp: false,
         isBlueprints: true,
-        isWorkbenchApp: false,
+        // federated so the build emits mf-manifest.json for Brett; like `sanity build` for a
+        // `defineApplication` studio, this drops the auto-updates import map
+        isWorkbenchApp: true,
+        workbenchAppId: appId,
         minify: resource.minify ?? true,
         outDir,
         output,
@@ -134,6 +145,21 @@ async function buildStudioBundle({ resource, appId, workDir, outDir, output, eve
         workDir,
         eventListener,
     });
+    if (mfManifest) {
+        resource.mfManifest = mfManifest;
+    }
+    const { schemaInputs } = await buildStudioSchemasAndManifests(appId, {
+        configPath: resource.root,
+        isExternal: false,
+        outPath: outDir,
+        projectId,
+        schemaRequired: false,
+        verbose: false,
+        workDir,
+    });
+    if (schemaInputs) {
+        resource.schemaInputs = schemaInputs;
+    }
     return { mismatchedPackages };
 }
 async function buildApplicationBundle({ resource, appId, workDir, outDir, output, eventListener, }) {
@@ -142,7 +168,7 @@ async function buildApplicationBundle({ resource, appId, workDir, outDir, output
     if (extraWindow) {
         throw new Error(`Application resource '${resource.name}' declares more than one window view; at most one is allowed`);
     }
-    await buildApp({
+    const { mfManifest } = await buildApp({
         ...sharedBuildAppOptions({ appId, workDir, outDir, output, eventListener }),
         appId,
         appTitle: resource.title,
@@ -153,11 +179,14 @@ async function buildApplicationBundle({ resource, appId, workDir, outDir, output
             webWorkers: resource.webWorkers,
         },
     });
+    if (mfManifest) {
+        resource.mfManifest = mfManifest;
+    }
     // a workbench app never auto-updates, so no dependency mismatches are compared
     return {};
 }
 async function buildInstallationConfigBundle({ resource, workDir, outDir, output, eventListener, }) {
-    await buildApp({
+    const { mfManifest } = await buildApp({
         ...sharedBuildAppOptions({ appId: undefined, workDir, outDir, output, eventListener }),
         appId: undefined,
         appTitle: undefined,
@@ -165,6 +194,9 @@ async function buildInstallationConfigBundle({ resource, workDir, outDir, output
         workbenchAppId: undefined,
         exposes: { config: { appType: resource.appType, fields: resource.fields } },
     });
+    if (mfManifest) {
+        resource.mfManifest = mfManifest;
+    }
     return {};
 }
 // Options a workbench build (application or installation config) always sets the
@@ -247,6 +279,8 @@ function createSilentOutput() {
             return undefined;
         },
         log() { },
+        logDiagnostic(_message) { },
+        logJson(_json) { },
         warn(input) {
             return input;
         },
@@ -260,12 +294,12 @@ async function getInstalledSanityVersion(workDir) {
         return undefined;
     }
 }
-function getAppId(resource) {
-    if ('externalId' in resource && typeof resource.externalId === 'string' && resource.externalId) {
-        return resource.externalId;
+function getAppId(resolvedResource) {
+    if (resolvedResource.externalId) {
+        return resolvedResource.externalId;
     }
-    else if (resource.lifecycle?.ownershipAction?.type === 'attach') {
-        return resource.lifecycle.ownershipAction.id;
+    else if (resolvedResource.resource.lifecycle?.ownershipAction?.type === 'attach') {
+        return resolvedResource.resource.lifecycle.ownershipAction.id;
     }
     return undefined;
 }

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

@@ -1,5 +1,7 @@
 import {performance} from 'node:perf_hooks'
 import {inspect} from 'node:util'
+import {getBatchResults} from './getBatchResults.js'
+import {createStepHistory} from './step-history.js'
 
 /**
  *
@@ -23,10 +25,13 @@ const formatArgs = (args) =>
  * @param handler - callback being run
  * @param context - data to send to the operation
  * @param event - the step being run
+ * @param [branchName] - the name of the branch being run
  * @param io
  */
-export async function runDurable(handler, {context, event}, io) {
+export async function runDurable(handler, {context, event, branchName}, io) {
+  const history = createStepHistory()
   let currentStep = null
+
   const streamLog = (level, args) => {
     const date = new Date()
     const timestamp = `${date.toLocaleDateString()} ${date.toLocaleTimeString()}`
@@ -41,7 +46,6 @@ export async function runDurable(handler, {context, event}, io) {
     })
   }
 
-  // @todo: need to throw error for use of `console.log` in a durable function
   const logger = {
     log: (...a) => streamLog('info', a),
     info: (...a) => streamLog('info', a),
@@ -49,24 +53,57 @@ export async function runDurable(handler, {context, event}, io) {
     error: (...a) => streamLog('error', a),
   }
 
-  const track = async (name, kind, produce) => {
-    io.emit({name, kind, phase: 'start'})
-    const startedAt = performance.now()
+  const emitFailure = (pending) => {
+    history.settle(pending)
+    io.emit(pending.event)
+  }
+
+  const settleUnretried = () => {
+    const pending = history.getPending()
+    if (pending !== null) {
+      emitFailure(pending)
+    }
+  }
+
+  const track = async (name, kind, produce, retry) => {
+    settleUnretried()
+    const {index, saved} = history.nextStep()
+
+    if (saved?.phase === 'complete') {
+      return saved.output
+    }
+
+    const maxAttempts = retry?.maxAttempts ?? 1
+    const retries = Math.max((retry?.maxAttempts ?? 1) - 1, 0)
+    const waitingOnRetry = typeof saved?.retryDelayMs === 'number'
+
+    if (saved?.phase === 'error' && !waitingOnRetry) {
+      throw saved.output
+    }
+
+    const attempt = (saved?.attempt ?? 0) + 1
     const prev = currentStep
     currentStep = name
 
+    io.emit({name, kind, phase: 'start'})
+    const startedAt = performance.now()
+
     try {
-      const value = await produce()
-      io.emit({
+      const value = await produce(attempt)
+      const completeEvent = {
         name,
         kind,
         phase: 'complete',
         output: value,
         durationMs: performance.now() - startedAt,
-      })
+      }
+
+      history.recordSuccess(index, completeEvent)
+      io.emit(completeEvent)
+
       return value
     } catch (err) {
-      io.emit({
+      const errorEvent = {
         name,
         kind,
         phase: 'error',
@@ -76,20 +113,81 @@ export async function runDurable(handler, {context, event}, io) {
           stack: err?.stack ?? '',
         },
         durationMs: performance.now() - startedAt,
+        attempt,
+        retries,
+        maxAttempts,
+      }
+
+      const retryPending = history.recordFailure(index, {
+        event: errorEvent,
+        error: err,
+        delayMs: retry?.delay ? durationToMs(retry.delay) : 0,
       })
+
+      if (!retryPending) {
+        io.emit(errorEvent)
+      }
+
       throw err
     } finally {
       currentStep = prev
     }
   }
 
+  const FANOUT_STATUS = {
+    STARTED: 'STARTED',
+    ALL_COMPLETED: 'ALL_COMPLETED',
+    FAILURE_TOLERANCE_EXCEEDED: 'FAILURE_TOLERANCE_EXCEEDED',
+    SUCCEEDED: 'SUCCEEDED',
+    FAILED: 'FAILED',
+  }
+
   const step = {
-    run: ({name, handler: fn}) => track(name || '', 'run', () => fn({logger, attempt: 1})),
-    wait: ({name, duration}) =>
-      track(name || '', 'wait', async () => {
-        await io.wait(durationToMs(duration))
-        return undefined
-      }),
+    run: ({name, handler: fn, retry}) =>
+      track(name || '', 'run', (attempt) => fn({logger, attempt}), retry),
+    delegate: ({name, handler, event, retry}) =>
+      track(
+        name || '',
+        'delegate',
+        () => {
+          const fn = typeof handler === 'string' ? handler : handler?.name
+          if (!fn) {
+            throw new Error('No function name provided for delegation')
+          }
+          return io.invoke(fn, event?.data ?? {})
+        },
+        retry,
+      ),
+    fanout: async ({name, branches}) => {
+      if (
+        !Array.isArray(branches) ||
+        Array.from(branches).some((branch) => typeof branch !== 'function')
+      ) {
+        throw new TypeError('fanout branches must be an array of functions')
+      }
+
+      const outcomes = branches.map((_, index) => ({index, status: FANOUT_STATUS.STARTED}))
+      return new Promise((resolve, reject) => {
+        const execs = branches.map(async (branch, index) => {
+          try {
+            const branchName = `${name || 'fanout'} / branch ${index}`
+            const result = await runDurable(branch, {context, event, branchName}, io)
+            outcomes[index] = {index, status: FANOUT_STATUS.SUCCEEDED, result}
+          } catch (err) {
+            const error = err instanceof Error ? err : new Error(String(err))
+            outcomes[index] = {index, status: FANOUT_STATUS.FAILED, error}
+          }
+        })
+
+        Promise.allSettled(execs)
+          .then(() => {
+            resolve(getBatchResults(outcomes, FANOUT_STATUS.ALL_COMPLETED))
+          })
+          .catch(() => {
+            reject(reject)
+          })
+      })
+    },
     waitForCondition: ({name, initial, poller, next}) =>
       track(name || '', 'wait-for-condition', async () => {
         let state = initial
@@ -107,15 +205,35 @@ export async function runDurable(handler, {context, event}, io) {
         }
         return state
       }),
-    delegate: ({name, handler, event}) =>
-      track(name || '', 'delegate', () => {
-        const fn = typeof handler === 'string' ? handler : handler?.name
-        if (!fn) {
-          throw new Error('No function name provided for delegation')
-        }
-        return io.invoke(fn, event)
+    wait: ({name, duration}) =>
+      track(name || '', 'wait', async () => {
+        await io.wait(durationToMs(duration))
+        return undefined
       }),
   }
 
-  return handler({context, event, step, logger})
+  let result
+  let done = false
+  const handlerArgs = branchName !== undefined ? {step, logger} : {context, event, step, logger}
+  while (!done) {
+    history.startRun()
+    try {
+      result = await handler(handlerArgs)
+      settleUnretried()
+      done = true
+    } catch (err) {
+      const pending = history.getPending()
+      if (pending === null) {
+        throw err
+      }
+      if (err?.name === 'UnrecoverableError') {
+        emitFailure(pending)
+        throw err
+      }
+      io.emit({...pending.event, retryDelayMs: pending.delayMs})
+      await io.wait(pending.delayMs)
+    }
+  }
+
+  return result
 }

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

@@ -0,0 +1,75 @@
+/**
+ * Maps to runtime APIs from @sanity/functions
+ * @param outcomes - array of outcomes from the batch execution, each outcome should have a status and result or error
+ * @param reason - a string indicating the reason for the batch result, e.g., 'ALL_COMPLETED' or 'FAILED'
+ */
+export const getBatchResults = (outcomes, reason) => {
+  /**
+   * Returns an array of all outcomes, regardless of their status.
+   */
+  const all = outcomes.map((outcome) => ({...outcome}))
+
+  /**
+   * Returns an array of outcomes that have failed (status 'FAILED').
+   */
+  const failed = () =>
+    all.filter((outcome) => outcome.error !== undefined && outcome.status === 'FAILED')
+
+  /**
+   * Returns an array of outcomes that have succeeded (status 'SUCCEEDED').
+   */
+  const succeeded = () =>
+    all.filter((outcome) => outcome.result !== undefined && outcome.status === 'SUCCEEDED')
+
+  /**
+   * Returns an array of outcomes that are still in progress (status 'STARTED').
+   */
+  const started = () => all.filter((outcome) => outcome.status === 'STARTED')
+
+  /**
+   * Returns the count of successful outcomes (status 'SUCCEEDED')
+   */
+  const successCount = all.filter((item) => item.status === 'SUCCEEDED').length
+
+  /**
+   * Returns the count of failed outcomes (status 'FAILED')
+   */
+  const failureCount = all.filter((item) => item.status === 'FAILED').length
+
+  /**
+   * Returns an array of results from successful outcomes (status 'SUCCEEDED').
+   */
+  const getResults = () => succeeded().map((item) => item.result)
+
+  /**
+   * Returns an array of errors from failed outcomes (status 'FAILED').
+   */
+  const getErrors = () => failed().map((item) => item.error)
+
+  /**
+   * Throws the first error found in the failed outcomes (status 'FAILED').
+   */
+  const throwIfError = () => {
+    const failure = all.find((outcome) => outcome.status === 'FAILED')
+    if (failure?.error) {
+      throw failure.error
+    }
+  }
+
+  return {
+    all,
+    status: failureCount > 0 ? 'FAILED' : 'SUCCEEDED',
+    hasFailure: failureCount > 0,
+    failed,
+    succeeded,
+    started,
+    reason,
+    successCount,
+    failureCount,
+    startedCount: started().length,
+    totalCount: all.length,
+    getResults,
+    getErrors,
+    throwIfError,
+  }
+}

package/dist/utils/functions/child-runtime/step-history.d.ts

@@ -0,0 +1,15 @@
+import type {DurableStepEvent} from './types'
+
+type PendingRetry = {index: number; event: DurableStepEvent; delayMs: number}
+
+export function createStepHistory(): {
+  startRun: () => void
+  nextStep: () => {index: number; saved: DurableStepEvent | undefined}
+  recordSuccess: (index: number, event: DurableStepEvent) => void
+  recordFailure: (
+    index: number,
+    failure: {event: DurableStepEvent; error: unknown; delayMs: number},
+  ) => boolean
+  getPending: () => PendingRetry | null
+  settle: (pending: PendingRetry) => void
+}

package/dist/utils/functions/child-runtime/step-history.js

@@ -0,0 +1,52 @@
+const createStepHistory = () => {
+  const history = new Map([])
+  let cursor = 0
+  let pending = null
+
+  const startRun = () => {
+    cursor = 0
+  }
+
+  const nextStep = () => {
+    const index = cursor
+    cursor++
+    return {index, saved: history.get(index)}
+  }
+
+  const recordSuccess = (index, event) => {
+    history.set(index, event)
+  }
+
+  const recordFailure = (index, {event, error, delayMs}) => {
+    const retryable = event.attempt <= event.retries && error?.name !== 'UnrecoverableError'
+
+    if (retryable) {
+      history.set(index, {...event, output: error, retryDelayMs: delayMs})
+      pending = {index, event, delayMs}
+    } else {
+      history.set(index, {...event, output: error})
+    }
+    return retryable
+  }
+
+  const getPending = () => {
+    const item = pending
+    pending = null
+    return item
+  }
+
+  const settle = ({index, event}) => {
+    history.set(index, {...event, output: history.get(index).output})
+  }
+
+  return {
+    startRun,
+    nextStep,
+    recordSuccess,
+    recordFailure,
+    getPending,
+    settle,
+  }
+}
+
+export {createStepHistory}

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

@@ -64,10 +64,11 @@ export default async function invoke(resource, payload, context, options) {
     // Apply the GROQ rule before preparing a build so a filtered-out event skips
     // the (potentially expensive) transpile entirely.
     if (isGroqInvocation(resource)) {
-        if (!isGroqContextOptions(context)) {
+        if (!('clientOptions' in context)) {
             throw new Error('GROQ-based functions require a context with clientOptions');
         }
-        const { projectId, dataset } = context.clientOptions;
+        const projectId = 'projectId' in context.clientOptions ? context.clientOptions.projectId : undefined;
+        const dataset = 'dataset' in context.clientOptions ? context.clientOptions.dataset : undefined;
         if ('before' in payload) {
             filteredData = await applyGroqRule(resource, payload, projectId, dataset);
             const filter = resource.event && 'filter' in resource.event ? resource.event.filter : '';
@@ -173,12 +174,22 @@ export default async function invoke(resource, payload, context, options) {
                 // 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 },
-                    };
+                    // step.delegate errors need to be surfaced to the caller for retry behavior and for the durable step to be marked as failed.
+                    const origin = metadata?.origin || undefined;
+                    const error = nested.error || undefined;
+                    const response = origin === 'step.delegate' && error
+                        ? {
+                            type: 'invoke-response',
+                            id,
+                            ok: false,
+                            error,
+                        }
+                        : {
+                            type: 'invoke-response',
+                            id,
+                            ok: true,
+                            result: { json: nested.json },
+                        };
                     child.send(JSON.stringify(response));
                 }
             }

package/dist/utils/functions/invoke/resolve-invoke-type.d.ts

@@ -1,6 +1,6 @@
 import type { BlueprintResource } from '@sanity/blueprints';
 import type { Logger } from '../../logger.js';
-import type { EventType, FunctionGroqResource, FunctionResource, FunctionTestFlags, InvokeContextOptions, InvokePayloadOptions } from '../../types.js';
+import type { EventType, FunctionGroqResource, FunctionResource, FunctionTestFlags, InvokeContextOptions, InvokePayloadOptions, ResolvedResource } from '../../types.js';
 import buildPayload from '../build-payload.js';
 import { fetchAsset, fetchDocument } from '../fetch-document.js';
 export type InvocationPlan = {
@@ -23,7 +23,7 @@ export type InputContext = {
     apiHost: string;
     token?: string;
     withUserToken?: boolean;
-    resources: BlueprintResource[];
+    resolvedResources: ResolvedResource<BlueprintResource>[];
     blueprintFileDir: string;
     log: Logger;
 };

package/dist/utils/functions/invoke/resolve-invoke-type.js

@@ -51,7 +51,7 @@ export const buildContext = (plan, input) => {
     if (plan.kind === 'plain') {
         return {
             clientOptions: { ...withToken },
-            resources: input.resources,
+            resources: input.resolvedResources,
             blueprintFileDir: input.blueprintFileDir,
         };
     }
@@ -69,7 +69,7 @@ export const buildContext = (plan, input) => {
             '',
         functionResourceType: 'project',
         functionResourceId: input.projectId || '',
-        resources: input.resources,
+        resources: input.resolvedResources,
         blueprintFileDir: input.blueprintFileDir,
     };
 };