@sanity/runtime-cli 17.15.0 → 17.16.0-app-functions.ge0a25ea

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

@@ -1,5 +1,6 @@
 import {performance} from 'node:perf_hooks'
 import {inspect} from 'node:util'
+import {createStepHistory} from './step-history.js'
 
 /**
  *
@@ -26,7 +27,9 @@ const formatArgs = (args) =>
  * @param io
  */
 export async function runDurable(handler, {context, event}, io) {
+  const history = createStepHistory()
   let currentStep = null
+
   const streamLog = (level, args) => {
     const date = new Date()
     const timestamp = `${date.toLocaleDateString()} ${date.toLocaleTimeString()}`
@@ -41,7 +44,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 +51,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,7 +111,21 @@ 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
@@ -84,12 +133,21 @@ export async function runDurable(handler, {context, event}, io) {
   }
 
   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,
+      ),
     waitForCondition: ({name, initial, poller, next}) =>
       track(name || '', 'wait-for-condition', async () => {
         let state = initial
@@ -107,15 +165,34 @@ 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
+  while (!done) {
+    history.startRun()
+    try {
+      result = await handler({context, event, step, logger})
+      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/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
 }

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

@@ -10,6 +10,17 @@ export function createInvoker() {
   const pending = new Map()
   let invokeSeq = 0
 
+  function sendInvokeRequest(name, payload = {}, metadata = {}) {
+    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, metadata}))
+    })
+  }
+
   /**
    * `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.
@@ -18,14 +29,20 @@ export function createInvoker() {
    * @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}))
-    })
+    return sendInvokeRequest(name, payload)
+  }
+
+  /**
+   * durable `step.delegate(name, payload)` — ask the parent durable to execute another blueprint function
+   * and resolve with its return value. Sent over IPC and correlated by id. Adds an `origin` field to the message so the parent can
+   * distinguish between a normal invoke and a durable delegate for logging purposes.
+   * @param {string} name
+   * @param {Record<string, unknown>} [payload]
+   * @returns {Promise<unknown>}
+   */
+  function delegate(name, payload = {}) {
+    const metadata = {origin: 'step.delegate'}
+    return sendInvokeRequest(name, payload, metadata)
   }
 
   function handleResponse(msg) {
@@ -43,5 +60,5 @@ export function createInvoker() {
     }
   }
 
-  return {invoke, handleResponse}
+  return {delegate, invoke, handleResponse}
 }

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/extract-durable-config.js

@@ -5,7 +5,7 @@ import { SANITY_FUNCTION_DURABLE } from '../../constants.js';
 import { isLocalFunctionResource } from '../types.js';
 import { findFunctionEntryPoint } from './find-entry-point.js';
 import { transpileFunction } from './transpile/function.js';
-const DURABLE_CONFIG_KEYS = ['event', 'concurrency', 'debounce', 'debounceKey'];
+const DURABLE_CONFIG_KEYS = ['event', 'concurrency', 'debounce'];
 /**
  * Extracts the blueprint config from the function source code and mutates it to the resource object.
  * This is used for durable functions that may not have a config defined in the blueprint.
@@ -47,9 +47,6 @@ export const extractDurableConfig = async (resource, blueprintFileDir) => {
     if (resource.debounce === undefined && config?.debounce !== undefined) {
         resource.debounce = config.debounce;
     }
-    if (resource.debounceKey === undefined && config?.debounceKey !== undefined) {
-        resource.debounceKey = config.debounceKey;
-    }
     // Validate the resource after merging the config values
     const errors = validateDurableFunction(resource);
     if (errors.length > 0) {

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 : '';
@@ -156,14 +157,14 @@ export default async function invoke(resource, payload, context, options) {
         // Resolve a nested `context.invoke(name, payload)` by re-entering the invoke
         // pipeline via the supplied callback, then hand the result back to the child.
         async function handleNestedInvoke(msg) {
-            const { id, name, payload: nestedPayload } = msg;
+            const { id, name, payload: nestedPayload, metadata } = msg;
             pauseTimer();
             const nestedStart = performance.now();
             try {
                 if (!onNestedInvoke) {
                     throw new Error('Nested context.invoke is not supported in this context');
                 }
-                const nested = await onNestedInvoke(name, nestedPayload ?? {}, context, depth + 1, callStack);
+                const nested = await onNestedInvoke(name, nestedPayload ?? {}, context, depth + 1, callStack, metadata);
                 nestedTimings[`invoke:${name}`] =
                     (nestedTimings[`invoke:${name}`] ?? 0) + (performance.now() - nestedStart);
                 // Fire-and-forget contract: in production `context.invoke` returns once the
@@ -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));
                 }
             }
@@ -231,7 +242,12 @@ export default async function invoke(resource, payload, context, options) {
                 }
                 // Nested invoke request — handle without tearing down the child.
                 if (msg?.type === 'invoke-request') {
-                    handleNestedInvoke({ id: msg.id, name: msg.name, payload: msg.payload });
+                    handleNestedInvoke({
+                        id: msg.id,
+                        name: msg.name,
+                        payload: msg.payload,
+                        metadata: msg.metadata,
+                    });
                     return;
                 }
                 // Terminal result message.

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

@@ -28,7 +28,7 @@ export function assertNestedInvokeAllowed(name, depth, callStack) {
  * stack extended by this function, and normalize timings.
  */
 export async function runFunction(resource, payload, context, options) {
-    const { forceColor, timeout, depth = 0, callStack = [], onNestedInvoke } = options;
+    const { forceColor, timeout, depth = 0, callStack = [], onNestedInvoke, onStepEvent } = options;
     assertNestedInvokeAllowed(resource.name, depth, callStack);
     const response = await invoke(resource, payload, context, {
         forceColor,
@@ -36,6 +36,7 @@ export async function runFunction(resource, payload, context, options) {
         onNestedInvoke,
         depth,
         callStack: [...callStack, resource.name],
+        onStepEvent,
     });
     return { ...response, timings: response.timings ?? {} };
 }

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

package/dist/utils/functions/transpile/function.d.ts

@@ -1,10 +1,16 @@
+import type { Plugin } from 'vite';
 import type { FunctionResource, InstallerType } from '../../types.js';
 export declare const resolveViteRoot: (entry: string) => string;
-export declare function transpileFunction({ resource, functionPath, entryPoint, installer, }: {
+export declare function transpileFunction({ resource, functionPath, entryPoint, installer, workDir, outDir, outputFileName, bundle: bundleDependencies, plugins: extraPlugins, }: {
     resource: FunctionResource;
     functionPath: string;
     entryPoint: string;
     installer?: InstallerType;
+    workDir?: string;
+    outDir?: string;
+    outputFileName?: string;
+    bundle?: boolean;
+    plugins?: Plugin[];
 }): Promise<{
     type: string;
     outputDir: string;

package/dist/utils/functions/transpile/function.js

@@ -13,7 +13,7 @@ export const resolveViteRoot = (entry) => {
     const nodeModulesDir = find.dir('node_modules', { cwd: entry });
     return nodeModulesDir ? path.dirname(nodeModulesDir) : entry;
 };
-export async function transpileFunction({ resource, functionPath, entryPoint, installer, }) {
+export async function transpileFunction({ resource, functionPath, entryPoint, installer, workDir = cwd(), outDir, outputFileName = getOutputFilename(entryPoint), bundle: bundleDependencies, plugins: extraPlugins = [], }) {
     if (!resource.src)
         throw new Error('Resource src is required');
     if (!resource.name)
@@ -23,8 +23,8 @@ export async function transpileFunction({ resource, functionPath, entryPoint, in
     const stats = await stat(functionPath);
     const entryDir = stats.isFile() ? path.dirname(functionPath) : functionPath;
     const outputPathStart = performance.now();
-    const outputDir = await getTranspileOutputPath(entryDir, resource.name);
-    const outputFile = path.join(outputDir, getOutputFilename(entryPoint));
+    const outputDir = await getTranspileOutputPath(entryDir, resource.name, outDir);
+    const outputFile = path.join(outputDir, outputFileName);
     const fnRootDir = resolveViteRoot(entryDir);
     timings['transpile:setupOutput'] = performance.now() - outputPathStart;
     async function cleanupTmpDir() {
@@ -34,7 +34,8 @@ export async function transpileFunction({ resource, functionPath, entryPoint, in
     try {
         const viteStart = performance.now();
         // Always bundle the code if pnpm usage is detected or specified by the user
-        const bundle = !!find.file('pnpm-workspace.yaml') || installer === 'pnpm';
+        const bundle = bundleDependencies ??
+            (!!find.file('pnpm-workspace.yaml', { cwd: workDir }) || installer === 'pnpm');
         const result = await viteBuild({
             root: fnRootDir,
             logLevel: 'silent',
@@ -49,7 +50,7 @@ export async function transpileFunction({ resource, functionPath, entryPoint, in
                     input: entryPoint,
                     output: {
                         format: 'esm',
-                        entryFileNames: getOutputFilename(entryPoint),
+                        entryFileNames: outputFileName,
                         ...(bundle
                             ? {}
                             : {
@@ -71,7 +72,10 @@ export async function transpileFunction({ resource, functionPath, entryPoint, in
                     conditions: ['node'],
                 },
             },
-            plugins: bundle ? [detectNativeModulesPlugin(), pnpmResolvePlugin(cwd())] : [],
+            plugins: [
+                ...(bundle ? [detectNativeModulesPlugin(), pnpmResolvePlugin(workDir)] : []),
+                ...extraPlugins,
+            ],
         });
         timings['transpile:build'] = performance.now() - viteStart;
         const verifyStart = performance.now();
@@ -81,7 +85,7 @@ export async function transpileFunction({ resource, functionPath, entryPoint, in
         await writeTranspiledPackageJson(entryDir, outputFile);
         timings['transpile:writePackage'] = performance.now() - pkgStart;
         const cleanupStart = performance.now();
-        await cleanupSourceMaps(functionPath, outputDir);
+        await cleanupSourceMaps(entryDir, outputDir);
         timings['transpile:cleanupMaps'] = performance.now() - cleanupStart;
         timings.bundle = performance.now() - transpileStart;
         return {
@@ -148,8 +152,10 @@ async function writeTranspiledPackageJson(inputDir, outputFilePath) {
     const pkgJsonOutputPath = path.join(path.dirname(outputFilePath), 'package.json');
     await writeFile(pkgJsonOutputPath, JSON.stringify(bundled, null, 2));
 }
-async function getTranspileOutputPath(entryDir, fnName) {
-    const tmpPath = path.resolve(entryDir, '.build', `function-${fnName}`);
+async function getTranspileOutputPath(entryDir, fnName, outDir) {
+    const tmpPath = outDir
+        ? path.resolve(outDir)
+        : path.resolve(entryDir, '.build', `function-${fnName}`);
     await rm(tmpPath, { recursive: true, force: true }).catch(logCleanupFailure);
     await mkdir(tmpPath, { recursive: true });
     return tmpPath;

package/dist/utils/types.d.ts

@@ -40,6 +40,11 @@ export interface BlueprintResourceRecord extends BlueprintResource {
 export interface DeployedResource extends BlueprintResourceRecord {
     externalId: string;
 }
+/** Wrap a resource and its externalId if it has one. */
+export interface ResolvedResource<R extends BlueprintResource> {
+    resource: R;
+    externalId?: string;
+}
 export declare function isLocalFunctionResource(r: BlueprintResource): r is FunctionResource;
 export declare function hasEventSource(r: FunctionResource): r is EventFunctionResource;
 export declare function isScheduleEvent(e: unknown): e is BlueprintScheduledFunctionResource['event'];
@@ -134,8 +139,14 @@ export type InvokePayloadMetadata = Pick<InvokeGroqPayloadOptions, 'event' | 'be
 export type EventType = 'create' | 'update' | 'delete';
 export type NonGroqEventType = 'plain' | 'nested' | 'durable';
 export declare function isEventType(arg: string): arg is EventType;
+interface BaseContextOptions {
+    /** All resources declared by the blueprint, used to populate `context.resources` at invoke time. */
+    resources?: ResolvedResource<BlueprintResource>[];
+    /** The directory where the blueprint manifest is located. */
+    blueprintFileDir: string;
+}
 /** @internal */
-export interface InvokeGroqContextOptions {
+export interface InvokeGroqContextOptions extends BaseContextOptions {
     clientOptions: {
         apiVersion?: string;
         dataset?: string;
@@ -151,20 +162,12 @@ export interface InvokeGroqContextOptions {
     functionResourceType: string;
     /** The resource ID of the function container; resource ID that houses the function. */
     functionResourceId: string;
-    /** All resources declared by the blueprint, used to populate `context.resources` at invoke time. */
-    resources?: BlueprintResource[];
-    /** The directory where the blueprint manifest is located. */
-    blueprintFileDir: string;
 }
 /** @internal */
-export interface InvokeScheduleContextOptions {
+export interface InvokeScheduleContextOptions extends BaseContextOptions {
     clientOptions: {
         token?: string;
     };
-    /** All resources declared by the blueprint, used to populate `context.resources` at invoke time. */
-    resources?: BlueprintResource[];
-    /** The directory where the blueprint manifest is located. */
-    blueprintFileDir: string;
 }
 export type InvokeContextOptions = InvokeGroqContextOptions | InvokeScheduleContextOptions;
 export declare function isGroqContextOptions(context: InvokeContextOptions): context is InvokeGroqContextOptions;
@@ -187,12 +190,15 @@ export interface InvokeExecutionOptions {
     /** Don't wait the full duration during a wait durable event @internal */
     noWait?: boolean;
 }
+export type NestedInvokeMetadata = {
+    origin?: 'step.delegate';
+};
 /**
  * Re-entrant callback that executes a named function from the blueprint on behalf
  * of a nested `context.invoke(name, payload)` and returns its invocation result.
  * @internal
  */
-export type NestedInvoke = (name: string, payload: Record<string, unknown>, context: InvokeContextOptions, depth: number, callStack: string[]) => Promise<InvocationResponse & {
+export type NestedInvoke = (name: string, payload: Record<string, unknown>, context: InvokeContextOptions, depth: number, callStack: string[], metadata?: NestedInvokeMetadata) => Promise<InvocationResponse & {
     timings: Record<string, number>;
 }>;
 /**
@@ -233,6 +239,7 @@ export type ChildToParentMessage = {
     name: string;
     payload: Record<string, unknown>;
     isDurable?: boolean;
+    metadata?: NestedInvokeMetadata;
 } | {
     type: 'result';
     json?: JsonInvocationResponse;
@@ -334,7 +341,7 @@ export type AssetPrepResult = {
     error: string;
 };
 export type PrepAssetFn<R extends BlueprintResource> = (options: {
-    resource: R;
+    resolvedResource: ResolvedResource<R>;
     blueprintFileDir: string;
     installer?: InstallerType;
 }) => Promise<AssetPrepResult>;
@@ -351,7 +358,7 @@ export type PreDeployConfig = {
     prepareResource?: PrepResourceFn<BlueprintResource>;
 };
 export type AssetResource<R extends BlueprintResource> = {
-    resource: R;
+    resource: ResolvedResource<R>;
     prepareAsset: PrepAssetFn<R>;
 };
 export type Warning = {
@@ -372,6 +379,10 @@ export interface DurableStepEvent {
     output?: unknown;
     error?: InvocationError;
     durationMs?: number;
+    retryDelayMs?: number;
+    attempt?: number;
+    retries?: number;
+    maxAttempts?: number;
 }
 export interface DurableLogEvent {
     kind: 'log';

package/dist/utils/types.js

@@ -38,7 +38,7 @@ export function isEventType(arg) {
     return ['create', 'update', 'delete'].includes(arg);
 }
 export function isGroqContextOptions(context) {
-    return 'clientOptions' in context;
+    return 'eventResourceType' in context;
 }
 /** @internal */
 export var BlueprintParserErrorType;

package/oclif.manifest.json

@@ -3148,5 +3148,5 @@
       ]
     }
   },
-  "version": "17.15.0"
+  "version": "17.16.0-app-functions.ge0a25ea"
 }