@sanity/runtime-cli 17.7.1 → 17.8.0-next.g5972da4

package/dist/cores/blueprints/stacks.js

@@ -1,39 +1,78 @@
 import { listStacks } from '../../actions/blueprints/stacks.js';
-import { listProjects } from '../../actions/sanity/projects.js';
+import { listOrganizations, listProjects, } from '../../actions/sanity/projects.js';
+import { CI_SETUP_DOCS_URL } from '../../constants.js';
 import { formatStacksListing } from '../../utils/display/blueprints-formatting.js';
 import { capitalize, niceId, warn } from '../../utils/display/presenters.js';
+import { promptForOrganization, promptForProjectInOrg, promptForScope, promptForScopeRecovery, } from '../../utils/display/prompt.js';
+import { isInteractive } from '../../utils/interactive.js';
 import { styleText } from '../../utils/style-text.js';
-/** Max projects to query for stacks during --include-projects */
+/** Max projects to query for stacks within one organization */
 const PROJECT_LIMIT = 50;
+/** Max projects to query for stacks across every organization */
+const ALL_PROJECTS_LIMIT = 200;
+/** Stack listings in flight while querying many scopes */
+const SCOPE_CONCURRENCY = 5;
 export async function blueprintStacksCore(options) {
-    const { log, token, scopeType, scopeId, localStackId: blueprintStackId, flags } = options;
-    const { 'include-projects': includeProjects = false } = flags;
-    if (includeProjects && scopeType === 'organization') {
-        return deepListStacks({ organizationId: scopeId, token, log, blueprintStackId });
-    }
+    const { bin, log, token, localStackId: blueprintStackId, flags } = options;
+    const { all = false, 'include-projects': includeProjects = false, json = false } = flags;
     try {
-        const spinner = log.ora('Fetching Stacks...').start();
-        const { ok, stacks, error } = await listStacks({ token, scopeType, scopeId }, log);
-        if (!ok) {
-            spinner.fail('Failed to list Stacks');
-            const suggestions = [];
-            if (error && /access|permission|forbidden/i.test(error)) {
-                suggestions.push('Verify you have access to this organization or project.', `Try a different scope with --project-id or --organization-id.`);
+        if (all)
+            return await listStacksEverywhere({ token, log, blueprintStackId });
+        let { scopeType, scopeId } = options;
+        let displayName;
+        let promptedForScope = false;
+        let hasAlternativeScope = false;
+        while (true) {
+            if (!scopeType || !scopeId) {
+                if (!isInteractive || json)
+                    return missingScopeResult(bin);
+                const chosen = await chooseScope({ token, log });
+                scopeType = chosen.scopeType;
+                scopeId = chosen.scopeId;
+                displayName = chosen.displayName;
+                hasAlternativeScope = chosen.hasAlternativeScope;
+                promptedForScope = true;
             }
-            return {
-                success: false,
-                error: error || 'Failed to list stacks',
-                suggestions: suggestions.length ? suggestions : undefined,
-            };
-        }
-        spinner.stop().clear();
-        if (!stacks || stacks.length === 0) {
-            log('No stacks found');
-            return { success: true };
+            if (includeProjects && scopeType === 'organization') {
+                return await listStacksAcrossOrganization({
+                    organizationId: scopeId,
+                    token,
+                    log,
+                    blueprintStackId,
+                });
+            }
+            const spinner = log.ora('Fetching Stacks...').start();
+            const result = await listStacks({ token, scopeType, scopeId }, log);
+            if (!result.ok) {
+                if (promptedForScope && hasAlternativeScope && result.response?.status === 403) {
+                    spinner.stop().clear();
+                    log(warn(`Your account can see ${scopeTargetLabel({ scopeType, scopeId, displayName })}, but cannot read its Blueprint Stacks.`));
+                    const recovery = await promptForScopeRecovery();
+                    if (recovery === 'retry') {
+                        scopeType = undefined;
+                        scopeId = undefined;
+                        displayName = undefined;
+                        hasAlternativeScope = false;
+                        continue;
+                    }
+                }
+                else {
+                    spinner.fail('Failed to list Stacks');
+                }
+                return listStacksFailure(result.error, result.response?.status);
+            }
+            spinner.stop().clear();
+            if (result.stacks.length === 0) {
+                log('No stacks found');
+                return { success: true, json: { stacks: [], scopeType, scopeId } };
+            }
+            printStackGroups({
+                groups: [{ scopeType, scopeId, displayName, stacks: result.stacks }],
+                log,
+                blueprintStackId,
+            });
+            return { success: true, json: { stacks: result.stacks, scopeType, scopeId } };
         }
-        log(`${styleText('bold', capitalize(scopeType))} ${niceId(scopeId)} ${styleText('bold', 'Stacks')}:\n`);
-        log(formatStacksListing(stacks, blueprintStackId));
-        return { success: true, json: { stacks, scopeType, scopeId } };
     }
     catch (error) {
         const errorMessage = error instanceof Error ? error.message : String(error);
@@ -41,71 +80,229 @@ export async function blueprintStacksCore(options) {
         return { success: false, error: errorMessage };
     }
 }
-async function deepListStacks(options) {
+function listStacksFailure(error, status) {
+    return {
+        success: false,
+        error: error || 'Failed to list stacks',
+        suggestions: status === 403
+            ? [
+                'Ask an administrator to grant you read access to Blueprint Stacks for this organization or project.',
+                'Try a different scope with --project-id or --organization-id.',
+            ]
+            : undefined,
+    };
+}
+function missingScopeResult(bin) {
+    return {
+        success: false,
+        error: 'Missing scope: provide --project-id or --organization-id.',
+        suggestions: [
+            `Run \`${bin} blueprints stacks --all\` to list Stacks for every organization and project.`,
+            'Set SANITY_PROJECT_ID or SANITY_ORGANIZATION_ID when no terminal is available.',
+        ],
+        ref: CI_SETUP_DOCS_URL,
+    };
+}
+/** Organization, then project when the user picks project scope. */
+async function chooseScope(options) {
+    const { token, log } = options;
+    const orgResult = await promptForOrganization({ token, logger: log });
+    if (typeof orgResult === 'symbol')
+        throw new Error('Unexpected back navigation');
+    const scopeType = await promptForScope({
+        hasProjects: orgResult.projects.length > 0,
+        message: 'Which Stacks would you like to list?',
+    });
+    if (typeof scopeType === 'symbol')
+        throw new Error('Unexpected back navigation');
+    if (scopeType === 'organization') {
+        const { id, name } = orgResult.organization;
+        return {
+            scopeType,
+            scopeId: id,
+            displayName: name,
+            hasAlternativeScope: orgResult.wasPrompted || orgResult.projects.length > 0,
+        };
+    }
+    const project = await promptForProjectInOrg({ projects: orgResult.projects, logger: log });
+    if (typeof project === 'symbol')
+        throw new Error('Unexpected back navigation');
+    return {
+        scopeType,
+        scopeId: project.projectId,
+        displayName: project.displayName,
+        // The containing organization is another possible scope even when it has no other projects.
+        hasAlternativeScope: true,
+    };
+}
+async function listStacksAcrossOrganization(options) {
     const { organizationId, token, log, blueprintStackId } = options;
-    const allStacks = [];
     const spinner = log.ora('Fetching Stacks...').start();
-    try {
-        // 1. Org-scoped stacks
-        const orgResult = await listStacks({ token, scopeType: 'organization', scopeId: organizationId }, log);
-        const orgStacks = orgResult.ok ? orgResult.stacks : [];
-        // 2. Get projects in the organization
-        const projectsResult = await listProjects({ token, organizationId, logger: log });
-        if (!projectsResult.ok) {
-            spinner.fail('Failed to list projects');
-            return { success: false, error: projectsResult.error || 'Failed to list projects' };
+    const projectsResult = await listProjects({ token, organizationId, logger: log });
+    if (!projectsResult.ok) {
+        spinner.fail('Failed to list projects');
+        return { success: false, error: projectsResult.error || 'Failed to list projects' };
+    }
+    const projects = projectsResult.projects;
+    const targets = [
+        { scopeType: 'organization', scopeId: organizationId },
+        ...projectTargets(projects.slice(0, PROJECT_LIMIT)),
+    ];
+    const { groups, failures, successfulScopes } = await collectStackGroups({
+        targets,
+        token,
+        log,
+        onProgress: (completed, total) => {
+            spinner.text = `Fetching Stacks... (${completed}/${total})`;
+        },
+    });
+    if (successfulScopes === 0 && failures.length > 0) {
+        spinner.fail('Failed to list Stacks');
+        return listStacksFailure(failures[0].error, failures[0].status);
+    }
+    spinner.stop().clear();
+    const stacks = groups.flatMap((group) => group.stacks);
+    if (stacks.length > 0)
+        printStackGroups({ groups, log, blueprintStackId });
+    else
+        log('No stacks found');
+    const organizationFailure = failures.find(({ target }) => target.scopeType === 'organization');
+    if (organizationFailure) {
+        log(warn(`Could not read organization-scoped Stacks: ${organizationFailure.error}`));
+    }
+    const projectFailures = failures.filter(({ target }) => target.scopeType === 'project');
+    if (projectFailures.length > 0) {
+        const projectCount = targets.filter(({ scopeType }) => scopeType === 'project').length;
+        log(warn(`Could not read Stacks for ${projectFailures.length} of ${projectCount} projects.`));
+        for (const { target, error } of projectFailures) {
+            log.verbose(`Project ${target.scopeId}: ${error}`);
         }
-        const projects = projectsResult.projects;
-        const totalProjects = projects.length;
-        const cappedProjects = projects.slice(0, PROJECT_LIMIT);
-        // 3. Fetch stacks for each project
-        const projectGroups = [];
-        for (let i = 0; i < cappedProjects.length; i++) {
-            const project = cappedProjects[i];
-            spinner.text = `Fetching Stacks... (project ${i + 1}/${cappedProjects.length})`;
-            const result = await listStacks({ token, scopeType: 'project', scopeId: project.id }, log);
-            if (result.ok && result.stacks.length > 0) {
-                projectGroups.push({
-                    projectId: project.id,
-                    displayName: project.displayName,
-                    stacks: result.stacks,
+    }
+    if (projects.length > PROJECT_LIMIT)
+        log(projectLimitWarning(projects.length, PROJECT_LIMIT));
+    return { success: true, json: { stacks, scopeType: 'organization', scopeId: organizationId } };
+}
+/** Every organization and project the token can reach, skipping the scopes it cannot read. */
+async function listStacksEverywhere(options) {
+    const { token, log, blueprintStackId } = options;
+    const spinner = log.ora('Finding organizations and projects...').start();
+    const [orgsResult, projectsResult] = await Promise.all([
+        listOrganizations({ token, logger: log }),
+        listProjects({ token, logger: log }),
+    ]);
+    if (!orgsResult.ok && !projectsResult.ok) {
+        spinner.fail('Failed to list organizations and projects');
+        return {
+            success: false,
+            error: orgsResult.error || projectsResult.error || 'Failed to list organizations',
+        };
+    }
+    const discoveryWarnings = [];
+    if (!orgsResult.ok) {
+        discoveryWarnings.push(`Could not list organizations: ${orgsResult.error || 'unknown error'}`);
+    }
+    if (!projectsResult.ok) {
+        discoveryWarnings.push(`Could not list projects: ${projectsResult.error || 'unknown error'}`);
+    }
+    const organizations = orgsResult.ok ? orgsResult.organizations : [];
+    const projects = projectsResult.ok ? projectsResult.projects : [];
+    const targets = buildScopeTargets(organizations, projects.slice(0, ALL_PROJECTS_LIMIT));
+    spinner.text = 'Fetching Stacks...';
+    const { groups, failures, successfulScopes } = await collectStackGroups({
+        targets,
+        token,
+        log,
+        onProgress: (completed, total) => {
+            spinner.text = `Fetching Stacks... (${completed}/${total})`;
+        },
+    });
+    if (targets.length > 0 && successfulScopes === 0) {
+        spinner.fail('Failed to list Stacks');
+        return listStacksFailure(failures[0]?.error, failures[0]?.status);
+    }
+    spinner.stop().clear();
+    const stacks = groups.flatMap((group) => group.stacks);
+    if (stacks.length > 0)
+        printStackGroups({ groups, log, blueprintStackId });
+    else if (targets.length === 0)
+        log('No organizations or projects found');
+    else
+        log('No stacks found');
+    for (const message of discoveryWarnings)
+        log(warn(message));
+    if (projects.length > ALL_PROJECTS_LIMIT) {
+        log(projectLimitWarning(projects.length, ALL_PROJECTS_LIMIT));
+    }
+    if (failures.length > 0) {
+        log(warn(`Could not read Stacks for ${failures.length} of ${targets.length} scopes.`));
+        for (const { target, error } of failures) {
+            log.verbose(`${capitalize(target.scopeType)} ${target.scopeId}: ${error}`);
+        }
+    }
+    return { success: true, json: { stacks } };
+}
+async function collectStackGroups(options) {
+    const { targets, token, log, onProgress } = options;
+    const groups = [];
+    const failures = [];
+    let completed = 0;
+    let successfulScopes = 0;
+    for (let start = 0; start < targets.length; start += SCOPE_CONCURRENCY) {
+        const batch = await Promise.all(targets.slice(start, start + SCOPE_CONCURRENCY).map(async (target) => {
+            const { scopeType, scopeId } = target;
+            const result = await listStacks({ token, scopeType, scopeId }, log);
+            completed += 1;
+            onProgress?.(completed, targets.length);
+            return { target, result };
+        }));
+        for (const { target, result } of batch) {
+            if (!result.ok) {
+                failures.push({
+                    target,
+                    error: result.error || 'Failed to list stacks',
+                    status: result.response?.status,
                 });
-                allStacks.push(...result.stacks);
             }
-            else if (!result.ok) {
-                throw new Error(result.error);
+            else {
+                successfulScopes += 1;
+                if (result.stacks.length > 0)
+                    groups.push({ ...target, stacks: result.stacks });
             }
         }
-        spinner.stop().clear();
-        // 4. Print results
-        if (orgStacks.length > 0) {
-            log(`${styleText('bold', 'Organization')} ${niceId(organizationId)} ${styleText('bold', 'Stacks')}:\n`);
-            log(formatStacksListing(orgStacks, blueprintStackId));
-            if (projectGroups.length > 0)
-                log(''); // blank line between sections
-        }
-        for (const group of projectGroups) {
-            log(`${styleText('bold', 'Project')} "${group.displayName}" ${niceId(group.projectId)} ${styleText('bold', 'Stacks')}:`);
-            log(formatStacksListing(group.stacks, blueprintStackId));
-            log('');
-        }
-        if (totalProjects > PROJECT_LIMIT) {
-            log(warn(`Organization has ${totalProjects} projects, only checked the first ${PROJECT_LIMIT}.`));
-        }
-        if (orgStacks.length === 0 && allStacks.length === 0) {
-            log('No stacks found');
-            return { success: true };
-        }
-        allStacks.push(...orgStacks);
-        return {
-            success: true,
-            json: { stacks: allStacks, scopeType: 'organization', scopeId: organizationId },
-        };
     }
-    catch (error) {
-        spinner.stop().clear();
-        const errorMessage = error instanceof Error ? error.message : String(error);
-        log.error(`Error: ${errorMessage}`);
-        return { success: false, error: errorMessage };
+    return { groups, failures, successfulScopes };
+}
+function buildScopeTargets(organizations, projects) {
+    const organizationIds = new Set(organizations.map(({ id }) => id));
+    const targets = [];
+    for (const { id, name } of organizations) {
+        targets.push({ scopeType: 'organization', scopeId: id, displayName: name });
+        targets.push(...projectTargets(projects.filter((p) => p.organizationId === id)));
     }
+    targets.push(...projectTargets(projects.filter((p) => !organizationIds.has(p.organizationId))));
+    return targets;
+}
+function projectTargets(projects) {
+    return projects.map(({ id, displayName }) => ({
+        scopeType: 'project',
+        scopeId: id,
+        displayName,
+    }));
+}
+function scopeTargetLabel({ scopeType, scopeId, displayName }) {
+    const name = displayName ? ` "${displayName}"` : '';
+    return `${scopeType}${name} ${niceId(scopeId)}`;
+}
+function printStackGroups(options) {
+    const { groups, log, blueprintStackId } = options;
+    groups.forEach((group, index) => {
+        const name = group.displayName ? ` "${group.displayName}"` : '';
+        if (index > 0)
+            log('');
+        log(`${styleText('bold', capitalize(group.scopeType))}${name} ${niceId(group.scopeId)} ${styleText('bold', 'Stacks')}:\n`);
+        log(formatStacksListing(group.stacks, blueprintStackId));
+    });
+}
+function projectLimitWarning(total, limit) {
+    return warn(`Found ${total} projects, only checked the first ${limit}.`);
 }

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

@@ -1,29 +1,12 @@
 import type { ReadBlueprintResult } from '../../actions/blueprints/blueprint.js';
+import { type FunctionTestFlags } from '../../utils/types.js';
 import type { CoreConfig, CoreResult } from '../index.js';
 export interface FunctionTestOptions extends CoreConfig {
     blueprint: ReadBlueprintResult;
     args: {
         name: string | undefined;
     };
-    flags: {
-        data?: string;
-        event?: string;
-        file?: string;
-        timeout?: number;
-        api?: string;
-        dataset?: string;
-        'project-id'?: string;
-        'organization-id'?: string;
-        'document-id'?: string;
-        'with-user-token'?: boolean;
-        'data-before'?: string;
-        'data-after'?: string;
-        'file-before'?: string;
-        'file-after'?: string;
-        'document-id-before'?: string;
-        'document-id-after'?: string;
-        'media-library-id'?: string;
-    };
+    flags: FunctionTestFlags;
     error: (message: string, options: object) => void;
     helpText: string;
 }

package/dist/cores/functions/test.js

@@ -1,20 +1,30 @@
-import { readFileSync } from 'node:fs';
-import { dirname, join } from 'node:path';
-import { cwd } from 'node:process';
+import { dirname } from 'node:path';
 import { testAction } from '../../actions/functions/test.js';
 import config from '../../config.js';
-import { SANITY_FUNCTION_DOCUMENT, SANITY_FUNCTION_MEDIA_LIBRARY_ASSET } from '../../constants.js';
+import { STEP_PHASE_GLYPH } from '../../constants.js';
 import { resolveDeployedResources } from '../../utils/blueprints/resolve-deployed-resources.js';
-import buildPayload from '../../utils/functions/build-payload.js';
-import { fetchAsset, fetchDocument } from '../../utils/functions/fetch-document.js';
 import { findFunctionInResources, getFunctionNames } from '../../utils/functions/find.js';
 import { runFunction } from '../../utils/functions/invoke/nested.js';
-import { parseJsonObject } from '../../utils/parse-json-object.js';
+import { buildContext, buildInvokeOptions, collectInvokeInput, defaultInvocationDeps, resolveInvocationPlan, } from '../../utils/functions/invoke/resolve-invoke-type.js';
 import { isEventType, } from '../../utils/types.js';
+/**
+ * CLI lines for a durable run, in emission order; bare `start` events dropped.
+ * @param events
+ */
+function renderStepTimeline(events) {
+    return events
+        .filter((event) => event.phase !== 'start')
+        .map((event) => {
+        const glyph = STEP_PHASE_GLYPH[event.phase] ?? '•';
+        const duration = typeof event.durationMs === 'number' ? ` (${Math.round(event.durationMs)}ms)` : '';
+        const detail = event.phase === 'error' && event.error ? ` ${event.error.message}` : '';
+        return `  ${glyph} ${event.name} [${event.kind}]${duration}${detail}`;
+    });
+}
 export async function functionTestCore(options) {
     const { blueprint, log, error, args, flags, helpText } = options;
     const { name: fnName } = args;
-    const { data, event, file, timeout, api, dataset, 'document-id': documentId, 'with-user-token': withUserToken, 'data-before': dataBefore, 'data-after': dataAfter, 'file-before': fileBefore, 'file-after': fileAfter, 'document-id-before': documentIdBefore, 'document-id-after': documentIdAfter, 'media-library-id': mediaLibraryId, } = flags;
+    const { event, timeout, api, 'with-user-token': withUserToken } = flags;
     const { 'project-id': projectId = blueprint?.projectId, 'organization-id': organizationId = blueprint?.organizationId, } = flags;
     if (!fnName) {
         const functionNames = getFunctionNames(blueprint.resources);
@@ -40,8 +50,6 @@ export async function functionTestCore(options) {
     }
     try {
         const resource = findFunctionInResources(blueprint.resources, fnName); // throws if not found
-        const docFunction = resource.type === SANITY_FUNCTION_DOCUMENT;
-        const mediaFunction = resource.type === SANITY_FUNCTION_MEDIA_LIBRARY_ASSET;
         const resolvedResources = await resolveDeployedResources({
             resources: blueprint.resources,
             stackId: blueprint.stackId,
@@ -50,108 +58,31 @@ export async function functionTestCore(options) {
                 : undefined,
             logger: log,
         });
-        const blueprintFileDir = dirname(blueprint.fileInfo.blueprintFilePath);
-        const contextOptions = docFunction || mediaFunction
-            ? {
-                clientOptions: {
-                    apiVersion: api,
-                    dataset,
-                    projectId,
-                    organizationId,
-                },
-                eventResourceType: docFunction ? 'dataset' : 'media-library',
-                eventResourceId: (docFunction ? `${projectId}.${dataset}` : mediaLibraryId) || '',
-                functionResourceType: 'project',
-                functionResourceId: projectId || '',
-                resources: resolvedResources,
-                blueprintFileDir,
-            }
-            : { clientOptions: {}, resources: resolvedResources, blueprintFileDir };
-        // If the user sets the flag to use the real token set it in our options
-        if (withUserToken) {
-            contextOptions.clientOptions.token = config.token || undefined;
-        }
-        let before = null;
-        let after = null;
-        if (dataBefore && dataAfter) {
-            before = parseJsonObject(dataBefore);
-            after = parseJsonObject(dataAfter);
-        }
-        else if (fileBefore && fileAfter) {
-            let fileContents = readFileSync(join(cwd(), fileBefore), 'utf8');
-            before = parseJsonObject(fileContents);
-            fileContents = readFileSync(join(cwd(), fileAfter), 'utf8');
-            after = parseJsonObject(fileContents);
-        }
-        else if (documentIdBefore && documentIdAfter && docFunction) {
-            before = await fetchDocument(documentIdBefore, {
-                projectId,
-                dataset,
-                apiVersion: api,
-                apiHost: config.apiUrl,
-                token: config.token || undefined,
-            }, log);
-            after = await fetchDocument(documentIdAfter, {
-                projectId,
-                dataset,
-                apiVersion: api,
-                apiHost: config.apiUrl,
-                token: config.token || undefined,
-            }, log);
-        }
-        else if (documentIdBefore && documentIdAfter) {
-            before = await fetchAsset(documentIdBefore, {
-                mediaLibraryId,
-                apiVersion: api,
-                apiHost: config.apiUrl,
-                token: config.token || undefined,
-            }, log);
-            after = await fetchAsset(documentIdAfter, {
-                mediaLibraryId,
-                apiVersion: api,
-                apiHost: config.apiUrl,
-                token: config.token || undefined,
-            }, log);
-        }
-        let payload;
-        if (after) {
-            payload = after;
-        }
-        else {
-            if (documentId && docFunction) {
-                payload = await fetchDocument(documentId, {
-                    projectId,
-                    dataset,
-                    apiVersion: api,
-                    apiHost: config.apiUrl,
-                    token: config.token || undefined,
-                }, log);
-            }
-            else if (documentId) {
-                payload = await fetchAsset(documentId, {
-                    mediaLibraryId,
-                    apiVersion: api,
-                    apiHost: config.apiUrl,
-                    token: config.token || undefined,
-                }, log);
-            }
-            else {
-                payload = buildPayload({ data, file });
-            }
-        }
-        const invokeOptions = docFunction || mediaFunction
-            ? {
-                event: eventType,
-                payload,
-                before,
-                after,
-            }
-            : {
-                event: 'scheduled',
-            };
+        const input = {
+            flags,
+            projectId,
+            organizationId,
+            api,
+            apiHost: config.apiUrl,
+            token: config.token || undefined,
+            withUserToken,
+            resources: resolvedResources,
+            blueprintFileDir: dirname(blueprint.fileInfo.blueprintFilePath),
+            log,
+        };
+        const plan = resolveInvocationPlan(resource);
+        const context = buildContext(plan, input);
+        const invokeInput = await collectInvokeInput(plan, input, defaultInvocationDeps);
+        const invokeOptions = buildInvokeOptions(plan, invokeInput, eventType);
         // Records each nested context.invoke() so they can be surfaced in order after the spinner resolves.
         const nestedRuns = [];
         let nestedOrder = 0;
+        const stepEvents = [];
+        const onStepEvent = plan.isDurable
+            ? (event) => {
+                stepEvents.push(event);
+            }
+            : undefined;
         /**
          * Re-entrant callback that resolves a nested context.invoke(name, payload):
          * it finds the named function in the same blueprint, reuses the already
@@ -164,7 +95,7 @@ export async function functionTestCore(options) {
         const runNested = async (nestedName, nestedPayload, ctx, depth, callStack) => {
             const order = ++nestedOrder;
             const nestedResource = findFunctionInResources(blueprint.resources, nestedName);
-            const result = await runFunction(nestedResource, { payload: { data: nestedPayload }, event: 'nested' }, { ...ctx, resources: resolvedResources }, { depth, callStack, onNestedInvoke: runNested });
+            const result = await runFunction(nestedResource, { payload: nestedPayload, event: 'nested' }, { ...ctx, resources: resolvedResources }, { depth, callStack, onNestedInvoke: runNested });
             nestedRuns.push({ order, name: nestedName, logs: result.logs, error: result.error });
             return result;
         };
@@ -183,11 +114,12 @@ export async function functionTestCore(options) {
             }
         };
         const spinner = log.ora('Executing function...').start();
-        const { json: response, logs, error, } = await testAction(resource, invokeOptions, contextOptions, {
+        const { json: response, logs, error, } = await testAction(resource, invokeOptions, context, {
             timeout: timeout ? timeout : resource.timeout,
             onNestedInvoke: runNested,
             depth: 0,
             callStack: [fnName],
+            onStepEvent,
         });
         if (error) {
             spinner.fail('Function execution failed.');
@@ -199,6 +131,12 @@ export async function functionTestCore(options) {
             logNestedRuns();
             const errorMessage = error.stack || error.message || error.name;
             const isTimeout = error.message?.includes('Timeout');
+            if (plan.isDurable && stepEvents.length > 0) {
+                log('Steps:');
+                for (const line of renderStepTimeline(stepEvents)) {
+                    log(line);
+                }
+            }
             return {
                 success: false,
                 error: errorMessage,
@@ -216,6 +154,12 @@ export async function functionTestCore(options) {
             log('Response:');
             log(JSON.stringify(response, null, 2));
         }
+        if (plan.isDurable && stepEvents.length > 0) {
+            log('Steps:');
+            for (const line of renderStepTimeline(stepEvents)) {
+                log(line);
+            }
+        }
         return { success: true, json: { response, logs } };
     }
     catch (error) {