@sanity/runtime-cli 17.15.0 → 17.16.0-next.g05d3b7f

package/dist/cores/functions/logs.js

@@ -45,7 +45,7 @@ async function deleteLogs({ name, externalId, auth, force, log, }) {
     spinner.succeed('Logs deleted');
     return { success: true };
 }
-async function streamLogs({ name, externalId, auth, log, }) {
+async function streamLogs({ name, externalId, auth, utc, log, }) {
     const spinner = log.ora(`Setting up streaming logs session for function ${niceId(name)}`).start();
     try {
         spinner.stop();
@@ -58,7 +58,7 @@ async function streamLogs({ name, externalId, auth, log, }) {
             alreadyOpened = true;
         };
         const renderLog = (logEntry) => {
-            log(formatLog(logEntry, true));
+            log(formatLog(logEntry, utc));
         };
         streamLogsAction(externalId, auth, renderLog, onOpen, (error) => log.error(`${styleText('red', 'Error:')} ${error}`), log);
         // Return a special key for streaming mode
@@ -121,10 +121,7 @@ async function getLogs({ name, externalId, auth, limit, json, utc, log, }) {
  */
 function formatLog(entry, utc) {
     const { time, level, message, operationName, attempt, executionArn } = entry;
-    const date = new Date(time);
-    const [dateString, timeString] = utc
-        ? date.toISOString().slice(0, 19).split('T')
-        : [date.toLocaleDateString(), date.toLocaleTimeString()];
+    const [dateString, timeString] = formatTimestamp(new Date(time), utc);
     const durableAnnotation = durableLogAnnotation({ operationName, attempt, executionArn });
     return [
         styleText('bold', dateString),
@@ -134,6 +131,20 @@ function formatLog(entry, utc) {
         message,
     ].join(' ');
 }
+/**
+ * Formats a date as `[YYYY-MM-DD, HH:mm:ss]` in either UTC or local time.
+ * The shape is identical in both cases so `--utc` only changes the timezone.
+ * @param date
+ * @param utc
+ */
+export function formatTimestamp(date, utc) {
+    if (utc)
+        return date.toISOString().slice(0, 19).split('T');
+    const pad = (n) => n.toString().padStart(2, '0');
+    const dateString = `${date.getFullYear()}-${pad(date.getMonth() + 1)}-${pad(date.getDate())}`;
+    const timeString = `${pad(date.getHours())}:${pad(date.getMinutes())}:${pad(date.getSeconds())}`;
+    return [dateString, timeString];
+}
 /**
  * Log annotation for durable functions.
  * @param operationName

package/dist/cores/functions/test.js

@@ -1,7 +1,7 @@
 import { dirname } from 'node:path';
 import { testAction } from '../../actions/functions/test.js';
 import config from '../../config.js';
-import { STEP_PHASE_GLYPH } from '../../constants.js';
+import { SANITY_FUNCTION_DURABLE, STEP_PHASE_GLYPH } from '../../constants.js';
 import { resolveDeployedResources } from '../../utils/blueprints/resolve-deployed-resources.js';
 import { createDurableJsonCollector } from '../../utils/functions/durable-logs.js';
 import { findFunctionInResources, getFunctionNames } from '../../utils/functions/find.js';
@@ -55,7 +55,7 @@ export async function functionTestCore(options) {
             apiHost: config.apiUrl,
             token: config.token || undefined,
             withUserToken,
-            resources: resolvedResources,
+            resolvedResources,
             blueprintFileDir: dirname(blueprint.fileInfo.blueprintFilePath),
             log,
         };
@@ -88,15 +88,40 @@ export async function functionTestCore(options) {
          * surfaced after the spinner resolves, including failed ones — a downstream
          * error is fire-and-forget (it doesn't reject the caller) but is still shown.
          */
-        const runNested = async (nestedName, nestedPayload, ctx, depth, callStack) => {
+        const runNested = async (nestedName, nestedPayload, ctx, depth, callStack, metadata) => {
             const order = ++nestedOrder;
             const nestedResource = findFunctionInResources(blueprint.resources, nestedName);
-            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;
+            const isLiveDurable = metadata?.origin === 'step.delegate' && nestedResource.type === SANITY_FUNCTION_DURABLE;
+            if (isLiveDurable) {
+                log(`↳ BEGIN: invoke('${nestedName}')`);
+            }
+            try {
+                const result = await runFunction(nestedResource, { payload: nestedPayload, event: 'nested' }, { ...ctx, resources: resolvedResources }, { depth, callStack, onNestedInvoke: runNested, onStepEvent });
+                if (result.error && isLiveDurable) {
+                    log(result.error.stack || result.error.message);
+                }
+                nestedRuns.push({
+                    order,
+                    name: nestedName,
+                    logs: result.logs,
+                    error: result.error,
+                    isLiveDurable,
+                });
+                return result;
+            }
+            finally {
+                if (isLiveDurable) {
+                    log(`↳ END: invoke('${nestedName}')`);
+                }
+            }
         };
         const logNestedRuns = () => {
-            for (const run of [...nestedRuns].sort((a, b) => a.order - b.order)) {
+            // Remove buffered logs for durable runs
+            const runs = plan.isDurable ? nestedRuns.splice(0) : [...nestedRuns];
+            for (const run of runs.sort((a, b) => a.order - b.order)) {
+                // Skip if is Durable so log ordering is retained
+                if (run.isLiveDurable)
+                    continue;
                 log(`↳ BEGIN: invoke('${run.name}')`);
                 // Show any logs received
                 if (run.logs?.trim()) {
@@ -132,10 +157,19 @@ export async function functionTestCore(options) {
                 if (event.kind === 'delegate') {
                     logNestedRuns();
                 }
-                const glyph = STEP_PHASE_GLYPH[event.phase] ?? '•';
+                const willRetry = event.phase === 'error' && typeof event.retryDelayMs === 'number';
+                const glyph = willRetry ? '⟳' : (STEP_PHASE_GLYPH[event.phase] ?? '•');
                 const duration = typeof event.durationMs === 'number' ? ` (${Math.round(event.durationMs)}ms)` : '';
+                const retriesPerformed = (event.attempt ?? 1) - 1;
+                let retryNote = '';
+                if (willRetry) {
+                    retryNote = ` retry ${event.attempt} of ${event.maxAttempts}`;
+                }
+                else if (event.phase === 'error' && retriesPerformed > 0) {
+                    retryNote = ` failed after ${retriesPerformed} retries`;
+                }
                 const detail = event.phase === 'error' && event.error ? ` ${event.error.message}` : '';
-                lines.push(`  ${glyph} ${event.name} [${event.kind}]${duration}${detail}`);
+                lines.push(`  ${glyph} ${event.name} [${event.kind}]${duration}${detail}${retryNote}`);
             }
             return lines;
         }

package/dist/server/app.js

@@ -1,14 +1,14 @@
 import { existsSync, readFileSync, watchFile } from 'node:fs';
 import * as http from 'node:http';
 import { dirname } from 'node:path';
+import { resolveStackConfig } from '@sanity/blueprints/resolve';
 import { default as mime } from 'mime-types';
 import { WebSocket, WebSocketServer } from 'ws';
 import { findBlueprintFile, loadAndParseBlueprint } from '../actions/blueprints/blueprint.js';
 import { readConfigFile } from '../actions/blueprints/config.js';
-import { resolveIds } from '../actions/blueprints/resolve.js';
 import config from '../config.js';
 import { isRecord } from '../utils/is-record.js';
-import { isEventType, isGroqContextOptions, } from '../utils/types.js';
+import { isEventType, } from '../utils/types.js';
 import { handleInvokeRequest } from './handlers/invoke.js';
 const app = (host, port, validateResources, executionOptions) => {
     // Send a JSON envelope to every connected UI client.
@@ -47,7 +47,7 @@ const app = (host, port, validateResources, executionOptions) => {
                     const blueprint = await loadAndParseBlueprint(undefined, { validateResources });
                     const { parsedBlueprint, fileInfo, module: blueprintModule } = blueprint;
                     const blueprintConfig = readConfigFile(fileInfo.blueprintFilePath);
-                    const { projectId, organizationId } = resolveIds({
+                    const { projectId, organizationId } = resolveStackConfig({
                         module: blueprintModule,
                         config: blueprintConfig,
                     });
@@ -75,7 +75,7 @@ const app = (host, port, validateResources, executionOptions) => {
                             const { data, func: functionName, metadata, } = parseInvokeRequest(Buffer.concat(body), dirname(fileInfo.blueprintFilePath));
                             const { context, event } = data;
                             // replace user token if required
-                            if (isGroqContextOptions(context)) {
+                            if ('clientOptions' in context) {
                                 if (context.clientOptions.token) {
                                     context.clientOptions.token = config.token || undefined;
                                 }

package/dist/server/static/components/app.css

@@ -191,7 +191,7 @@ body {
 .border-right {
   border-right-width: 1px;
   border-right-style: solid;
-  border-top-color: var(--card-border-color);
+  border-right-color: var(--card-border-color);
 }
 
 .hr-border {
@@ -413,6 +413,13 @@ ol[type='content'] li:hover:not(.selected:not(.selected)) {
   border-right: none;
 }
 
+fieldset {
+  & :is(input:not([role='switch']), select, textarea) {
+    border: 1px solid light-dark(var(--gray-200), var(--gray-800)) !important;
+    border-radius: var(--radius-2);
+  }
+}
+
 & :is(input:not([is='switch']), select, textarea) {
   border: 1px solid light-dark(var(--gray-200), var(--gray-800)) !important;
   border-radius: var(--radius-2);

package/dist/utils/blueprints/group-resources.d.ts

@@ -1,8 +1,9 @@
 import type { BlueprintResource } from '@sanity/blueprints';
+import type { ResolvedResource } from '../types.js';
 export type GroupedBlueprintResource = {
     id: string;
     name: string;
     type: string;
 };
 export type GroupedBlueprintResources = Record<string, GroupedBlueprintResource[]>;
-export declare function groupBlueprintResources(blueprintResources: BlueprintResource[]): GroupedBlueprintResources;
+export declare function groupBlueprintResources(blueprintResources: ResolvedResource<BlueprintResource>[]): GroupedBlueprintResources;

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

@@ -12,10 +12,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,
@@ -260,12 +261,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-process-wrapper.js

@@ -86,7 +86,7 @@ process.on('message', async (data) => {
         {
           emit: (e) => process.send(JSON.stringify({type: 'step-event', event: e})),
           wait: (ms) => new Promise((resolve) => setTimeout(resolve, noWait ? 0 : ms)),
-          invoke: invoker.invoke,
+          invoke: invoker.delegate,
         },
       )
     } else {

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/invoke.d.ts

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