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

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,38 @@ 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)) {
+                // 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()) {

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/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/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
@@ -231,7 +232,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/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 = {

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-next.g8d59d6f"
 }

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@sanity/runtime-cli",
   "description": "Sanity's Runtime CLI for Blueprints and Functions",
-  "version": "17.15.0",
+  "version": "17.16.0-next.g8d59d6f",
   "author": "Sanity Runtime Team",
   "type": "module",
   "license": "MIT",
@@ -68,7 +68,7 @@
     "@oclif/core": "^4.14.0",
     "@oclif/plugin-help": "^6.3.0",
     "@sanity-labs/oclif-plugin-skills-flag": "^0.2.1",
-    "@sanity/blueprints": "^0.27.0",
+    "@sanity/blueprints": "^0.28.0",
     "@sanity/blueprints-parser": "^0.5.0",
     "@sanity/cli-build": "^6.3.0",
     "@sanity/cli-core": "^3.7.0",

package/dist/actions/blueprints/resolve.d.ts

@@ -1,51 +0,0 @@
-import type { ScopeType } from '../../utils/types.js';
-/**
- * Source of a resolved config value.
- * - flags: from CLI flags like `--project-id`
- * - env: from the environment - usually CLI var like `SANITY_ORGANIZATION_ID`
- * - module: from the blueprint module - undocumented escape hatch
- * - config: from the config file - .sanity/blueprint.config.json most common
- * - inferred: legacy `ST-<projectId>` stacks from launch
- */
-export type ConfigSource = 'flags' | 'env' | 'module' | 'config' | 'inferred';
-/** A set of optional IDs from a single source. */
-export interface IdValues {
-    organizationId?: string;
-    projectId?: string;
-    stackId?: string;
-}
-/**
- * Sources to resolve IDs from, in descending priority.
- * Each key maps to a source; the first non-empty value wins.
- *
- * - `env` defaults to reading SANITY_* process.env vars
- * - `module` and `config` accept any object with `{organizationId?, projectId?, stackId?}`
- */
-export interface IdSources {
-    flags?: IdValues | null;
-    env?: IdValues | null;
-    module?: IdValues | null;
-    config?: IdValues | null;
-}
-export interface ResolvedIds {
-    organizationId?: string;
-    projectId?: string;
-    stackId?: string;
-    scopeType?: ScopeType;
-    scopeId?: string;
-    sources: {
-        organizationId?: ConfigSource;
-        projectId?: ConfigSource;
-        stackId?: ConfigSource;
-    };
-}
-/**
- * Resolve organization, project, and stack IDs from a prioritized set of sources.
- * Precedence: flags > env > module > config.
- * Derives scopeType/scopeId from the resolved IDs (project > organization).
- *
- * Env vars are read from process.env by default (SANITY_ORGANIZATION_ID,
- * SANITY_PROJECT_ID, SANITY_BLUEPRINT_STACK_ID). Pass `env` explicitly to
- * override, or `null` to skip.
- */
-export declare function resolveIds(sources?: IdSources): ResolvedIds;