@sanity/runtime-cli 14.7.2 → 14.8.1

package/dist/cores/blueprints/deploy.js

@@ -4,7 +4,7 @@ import { setupLogStreaming } from '../../actions/blueprints/logs-streaming.js';
 import { getStack, updateStack } from '../../actions/blueprints/stacks.js';
 import { niceId } from '../../utils/display/presenters.js';
 import { styleText } from '../../utils/style-text.js';
-import { isLocalFunctionCollection, isLocalFunctionResource } from '../../utils/types.js';
+import { isLocalFunctionResource, isStudioResource } from '../../utils/types.js';
 const DEFAULT_ASSET_TIMEOUT = 60;
 const assetTimeoutS = Number(process.env.SANITY_ASSET_TIMEOUT) || DEFAULT_ASSET_TIMEOUT;
 const assetTimeoutMs = assetTimeoutS * 1000;
@@ -30,77 +30,13 @@ export async function blueprintDeployCore(options) {
         }
         const { resources } = blueprint.parsedBlueprint;
         const validResources = resources?.filter((r) => r.type) || [];
-        const functionResources = validResources.filter(isLocalFunctionResource);
-        const functionCollections = validResources.filter(isLocalFunctionCollection);
-        const allFunctionResources = [...functionResources, ...functionCollections];
-        // First stash all function assets
-        if (allFunctionResources.length > 0) {
-            log('Processing function assets...');
-            for (const resource of allFunctionResources) {
-                const fnSpinner = log.ora({ text: `Processing ${resource.name}...`, prefixText: ' ' }).start();
-                const warnTimer = setTimeout(() => {
-                    fnSpinner.text = `Still processing ${resource.name}, this can take a moment...`;
-                }, warnTimeoutMs);
-                let assetTimeoutTimer;
-                let result;
-                try {
-                    result = await Promise.race([
-                        stashAsset({ resource, auth, logger: log, installer }),
-                        new Promise((_, reject) => {
-                            assetTimeoutTimer = setTimeout(() => {
-                                reject(new Error(`Processing ${resource.name} timed out after ${assetTimeoutS}s`));
-                            }, assetTimeoutMs);
-                        }),
-                    ]);
-                }
-                catch (err) {
-                    const msg = err instanceof Error ? err.message : String(err);
-                    fnSpinner.fail(msg);
-                    return { success: false, error: msg };
-                }
-                finally {
-                    clearTimeout(warnTimer);
-                    clearTimeout(assetTimeoutTimer);
-                }
-                if (result.success && result.assetId) {
-                    resource.src = result.assetId;
-                    if (isLocalFunctionCollection(resource)) {
-                        try {
-                            for (const func of resource.functions) {
-                                func.src = func.name;
-                            }
-                            fnSpinner.succeed(`${resource.name} collection ${niceId(result.assetId)} (${resource.functions.length} functions)`);
-                            log(`   Functions: ${resource.functions.map((f) => f.name).join(', ')}`);
-                        }
-                        catch (err) {
-                            fnSpinner.fail(`Failed to update function collection ${resource.name}`);
-                            return {
-                                success: false,
-                                error: `Error updating function collection '${resource.name}': ${err instanceof Error ? err.message : String(err)}`,
-                            };
-                        }
-                    }
-                    else {
-                        fnSpinner.succeed(`${resource.name} ${niceId(result.assetId)}`);
-                        log(`   Source: ${resource.src}`);
-                    }
-                    if (result.hash) {
-                        if (result.hash.length > 24) {
-                            log.verbose(`   Hash: ${result.hash.slice(0, 8)}...${result.hash.slice(-12)}`);
-                        }
-                        else {
-                            log.verbose(`   Hash: ${result.hash}`);
-                        }
-                    }
-                    if (result.exists)
-                        log.verbose('   Asset unchanged');
-                }
-                else {
-                    const errorMsg = isLocalFunctionCollection(resource)
-                        ? `Failed uploading function collection ${resource.name} (${resource.functions?.length || 0} functions), deploy has stopped`
-                        : `Failed uploading ${resource.name} asset, deploy has stopped`;
-                    fnSpinner.fail(errorMsg);
-                    return { success: false, error: result.error || 'Failed to process function resource' };
+        const preDeployResources = validResources.filter(isPreDeployResource);
+        if (preDeployResources.length > 0) {
+            log('Processing assets...');
+            for (const resource of preDeployResources) {
+                const preDeployResult = await preDeploy(resource, { auth, installer, log });
+                if (preDeployResult.success === false) {
+                    return preDeployResult;
                 }
             }
         }
@@ -125,7 +61,7 @@ export async function blueprintDeployCore(options) {
         if (noWait) {
             log(styleText(['bold', 'green'], 'Stack deployment started!'));
             log(`Use \`npx ${bin} blueprints info\` to check status`);
-            return { success: true, data: { resources } };
+            return { success: true, json: { stackId: stack.id, resources }, data: { resources } };
         }
         log(styleText('dim', 'Stack deployment progress:'));
         let logStreamCleanup = null;
@@ -164,7 +100,7 @@ export async function blueprintDeployCore(options) {
                     if (logStreamCleanup)
                         logStreamCleanup();
                     log(styleText(['bold', 'green'], 'Stack deployment completed!'));
-                    return { success: true, data: { resources } };
+                    return { success: true, json: { stackId: stack.id, resources }, data: { resources } };
                 }
                 if (!idleMessageShown && Date.now() - lastLogAt > 60_000) {
                     log(`No new activity for 60 seconds. The deployment is still running on Sanity servers.`);
@@ -185,3 +121,55 @@ export async function blueprintDeployCore(options) {
         return { success: false, error: errorMessage };
     }
 }
+function isPreDeployResource(r) {
+    return isLocalFunctionResource(r) || isStudioResource(r);
+}
+async function preDeploy(resource, options) {
+    const { auth, installer, log } = options;
+    const fnSpinner = log.ora({ text: `Processing ${resource.name}...`, prefixText: ' ' }).start();
+    const warnTimer = setTimeout(() => {
+        fnSpinner.text = `Still processing ${resource.name}, this can take a moment...`;
+    }, warnTimeoutMs);
+    let assetTimeoutTimer;
+    let result;
+    try {
+        result = await Promise.race([
+            stashAsset({ resource, auth, logger: log, installer }),
+            new Promise((_, reject) => {
+                assetTimeoutTimer = setTimeout(() => {
+                    reject(new Error(`Processing ${resource.name} timed out after ${assetTimeoutS}s`));
+                }, assetTimeoutMs);
+            }),
+        ]);
+    }
+    catch (err) {
+        const msg = err instanceof Error ? err.message : String(err);
+        fnSpinner.fail(msg);
+        return { success: false, error: msg };
+    }
+    finally {
+        clearTimeout(warnTimer);
+        clearTimeout(assetTimeoutTimer);
+    }
+    if (result.success && result.assetId) {
+        resource.src = result.assetId;
+        fnSpinner.succeed(`${resource.name} ${niceId(result.assetId)}`);
+        log(`   Source: ${resource.src}`);
+        if (result.hash) {
+            if (result.hash.length > 24) {
+                log.verbose(`   Hash: ${result.hash.slice(0, 8)}...${result.hash.slice(-12)}`);
+            }
+            else {
+                log.verbose(`   Hash: ${result.hash}`);
+            }
+        }
+        if (result.exists)
+            log.verbose('   Asset unchanged');
+    }
+    else {
+        const errorMsg = `Failed uploading ${resource.name} asset, deploy has stopped`;
+        fnSpinner.fail(errorMsg);
+        return { success: false, error: result.error || 'Failed to process asset' };
+    }
+    return { success: true };
+}

package/dist/cores/blueprints/destroy.js

@@ -32,7 +32,7 @@ export async function blueprintDestroyCore(options) {
         if (!ok)
             return { success: false, error: error || 'Failed to destroy Stack deployment' };
         log(`Stack deployment "${stack.name}" ${niceId(stack.id)} destroyed`);
-        return { success: true };
+        return { success: true, json: { stackId: stack.id, stackName: stack.name } };
     }
     const { scopeType, scopeId, stackId } = blueprint;
     if (!scopeType || !scopeId)
@@ -92,7 +92,7 @@ export async function blueprintDestroyCore(options) {
         destroySpinner.stop().clear();
         if (noWait) {
             log(styleText(['bold', 'magenta'], 'Stack destruction started!'));
-            return { success: true };
+            return { success: true, json: { stackId: stack.id, stackName: stack.name } };
         }
         log(styleText('dim', 'Stack destruction progress:'));
         let logStreamCleanup = null;
@@ -117,7 +117,7 @@ export async function blueprintDestroyCore(options) {
                     if (logStreamCleanup)
                         logStreamCleanup();
                     log(styleText(['bold', 'magenta'], 'Stack destruction completed!'));
-                    return { success: true };
+                    return { success: true, json: { stackId: stack.id, stackName: stack.name } };
                 }
                 if (operation.status === 'FAILED') {
                     if (logStreamCleanup)

package/dist/cores/blueprints/doctor.js

@@ -273,7 +273,11 @@ export async function blueprintDoctorCore(options) {
         log(styleText(['bold', 'green'], 'All checks passed'));
         if (fix)
             log(styleText(['bold', 'yellow'], 'Nothing to fix; --fix flag is ignored'));
-        return { success: true, data: { diagnostics: flatDiagnostics } };
+        return {
+            success: true,
+            json: { diagnostics: flatDiagnostics },
+            data: { diagnostics: flatDiagnostics },
+        };
     }
     if (fix) {
         if (p) {

package/dist/cores/blueprints/info.js

@@ -6,7 +6,7 @@ export async function blueprintInfoCore(options) {
         log(formatStackInfo(deployedStack, true));
         if (deployedStack.resources)
             log(formatDeployedResourceTree(deployedStack.resources, verbose));
-        return { success: true };
+        return { success: true, json: { stack: deployedStack } };
     }
     catch (error) {
         const errorMessage = error instanceof Error ? error.message : String(error);

package/dist/cores/blueprints/init.d.ts

@@ -1,3 +1,4 @@
+import type { Logger } from '../../utils/logger.js';
 import type { ScopeType } from '../../utils/types.js';
 import type { CoreConfig, CoreResult } from '../index.js';
 export interface BlueprintInitOptions extends CoreConfig {
@@ -35,13 +36,13 @@ export declare function resolveScopeAndStack(params: {
     stackId: string | undefined;
     stackName: string | undefined;
     knownProjectId?: string;
-    log: CoreConfig['log'];
+    log: Logger;
     token: string;
 }): Promise<ResolvedScope>;
 export declare function determineBlueprintExtension(params: {
     requestedType: string | undefined;
     blueprintDir: string;
-    log: CoreConfig['log'];
+    log: Logger;
 }): Promise<string>;
 export declare function createBlueprintFiles(params: {
     blueprintDir: string;
@@ -51,6 +52,6 @@ export declare function createBlueprintFiles(params: {
     scopeId: string;
     stackId: string | undefined;
     bin: string;
-    log: CoreConfig['log'];
+    log: Logger;
 }): Promise<CoreResult>;
 export {};

package/dist/cores/blueprints/plan.js

@@ -63,5 +63,11 @@ export async function blueprintPlanCore(options) {
     else {
         log(`\n  ${styleText('dim', `No significant changes to deploy. Run \`npx ${bin} blueprints deploy\` to apply.`)}`);
     }
-    return { success: true };
+    return {
+        success: true,
+        json: {
+            resources: parsedBlueprint.resources,
+            plan: planResponse.deploymentPlan,
+        },
+    };
 }

package/dist/cores/blueprints/promote.d.ts

@@ -1,7 +1,6 @@
 import type { CoreResult, DeployedBlueprintConfig } from '../index.js';
 export interface BlueprintPromoteOptions extends DeployedBlueprintConfig {
     flags: {
-        'i-know-what-im-doing': boolean;
         force?: boolean;
         verbose?: boolean;
     };

package/dist/cores/blueprints/promote.js

@@ -4,9 +4,6 @@ import { promoteStack } from '../../actions/blueprints/stacks.js';
 import { niceId } from '../../utils/display/presenters.js';
 export async function blueprintPromoteCore(options) {
     const { log, stackId, auth, flags, deployedStack, blueprint } = options;
-    if (!flags['i-know-what-im-doing']) {
-        return { success: false, error: 'Seems you do not know what you are doing.' };
-    }
     let message = `"${deployedStack.name}" ${niceId(deployedStack.id)}`;
     if (deployedStack.scopeType === 'organization') {
         message = `Stack ${message} is already org-scoped. Promote again?`;
@@ -21,10 +18,13 @@ export async function blueprintPromoteCore(options) {
         }
     }
     try {
+        const spinner = log.ora('Promoting Stack...').start();
         const { ok, error, stack } = await promoteStack({ stackId, auth, logger: log });
         if (!ok) {
+            spinner.fail('Failed to promote Stack');
             return { success: false, error: error || 'Failed to promote Stack' };
         }
+        spinner.stop().clear();
         log(`Stack "${stack.name}" ${niceId(stack.id)} promoted successfully`);
         const { blueprintFilePath } = blueprint.fileInfo;
         try {
@@ -41,7 +41,7 @@ export async function blueprintPromoteCore(options) {
                 error: 'Stack promoted successfully but failed to update local Blueprint configuration. No config file found.',
             };
         }
-        return { success: true, data: { stack } };
+        return { success: true, json: { stack }, data: { stack } };
     }
     catch (error) {
         const errorMessage = error instanceof Error ? error.message : String(error);

package/dist/cores/blueprints/stacks.js

@@ -25,16 +25,20 @@ export async function blueprintStacksCore(options) {
         return { success: false, error: 'Unable to determine scope for Blueprint Stacks' };
     }
     try {
+        const spinner = log.ora('Fetching Stacks...').start();
         const { ok, stacks, error } = await listStacks({ token, scopeType, scopeId }, log);
-        if (!ok)
+        if (!ok) {
+            spinner.fail('Failed to list Stacks');
             return { success: false, error: error || 'Failed to list stacks' };
+        }
+        spinner.stop().clear();
         if (!stacks || stacks.length === 0) {
             log('No stacks found');
             return { success: true };
         }
         log(`${styleText('bold', capitalize(scopeType))} ${niceId(scopeId)} ${styleText('bold', 'Stacks')}:\n`);
         log(formatStacksListing(stacks, blueprintStackId));
-        return { success: true };
+        return { success: true, json: { stacks, scopeType, scopeId } };
     }
     catch (error) {
         const errorMessage = error instanceof Error ? error.message : String(error);

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

@@ -13,4 +13,5 @@ export interface FunctionAddOptions extends CoreConfig {
         install?: boolean;
     };
 }
+export declare const generateFunctionBlueprintResourceTemplate: (fnName: string, eventNames: string[]) => string;
 export declare function functionAddCore(options: FunctionAddOptions): Promise<CoreResult>;

package/dist/cores/functions/add.js

@@ -11,7 +11,7 @@ FUNCTION_TYPES, LABEL_DOCUMENT_CREATE, LABEL_DOCUMENT_DELETE, LABEL_DOCUMENT_UPD
 import { check, indent, warn } from '../../utils/display/presenters.js';
 import { styleText } from '../../utils/style-text.js';
 import { validateFunctionName } from '../../utils/validate/resource.js';
-const generateFunctionBlueprintResourceTemplate = (fnName, eventNames) => {
+export const generateFunctionBlueprintResourceTemplate = (fnName, eventNames) => {
     const functionType = eventNames[0].substring(0, eventNames[0].lastIndexOf('-'));
     let definer = '';
     const eventOns = eventNames.map((e) => `'${e.substring(e.lastIndexOf('-') + 1)}'`);
@@ -19,7 +19,7 @@ const generateFunctionBlueprintResourceTemplate = (fnName, eventNames) => {
         case 'document':
             definer = `defineDocumentFunction({name: '${fnName}', event: {on: [${eventOns.join(', ')}]}}), // ← add this line`;
             break;
-        case 'media':
+        case 'media-library-asset':
             definer = `defineMediaLibraryAssetFunction({name: '${fnName}', event: {on: [${eventOns.join(', ')}], resource: {type: 'media-library', id: 'my-media-library-id'}}}), // ← add this line`;
             break;
         case 'scheduled':

package/dist/cores/functions/build.js

@@ -28,7 +28,7 @@ export async function functionBuildCore(options) {
     for (const resource of functions) {
         const spinner = log.ora(`Building ${resource.name}...`).start();
         const prepResult = await prepareAsset({ resource }, { installer });
-        if (!prepResult.success || !prepResult.outputPath) {
+        if (prepResult.success === false) {
             spinner.fail(`Failed to build ${resource.name}`);
             errors.push({ name: resource.name, error: prepResult.error ?? 'Unknown error' });
             continue;
@@ -58,5 +58,5 @@ export async function functionBuildCore(options) {
         log.warn(`${errors.length} function(s) failed to build`);
     }
     log(`\nBuild complete: ${built.length} function(s)`);
-    return { success: true };
+    return { success: true, json: { built, errors, outDir } };
 }

package/dist/cores/functions/env/add.js

@@ -17,5 +17,5 @@ export async function functionEnvAddCore(options) {
         };
     }
     spinner.succeed(`Update of ${args.key} succeeded`);
-    return { success: true };
+    return { success: true, json: { name: args.name, key: args.key, value: args.value } };
 }

package/dist/cores/functions/env/list.js

@@ -16,5 +16,5 @@ export async function functionEnvListCore(options) {
     for (const key of result.envvars) {
         options.log(key);
     }
-    return { success: true };
+    return { success: true, json: { name: args.name, envvars: result.envvars } };
 }

package/dist/cores/functions/env/remove.js

@@ -14,5 +14,5 @@ export async function functionEnvRemoveCore(options) {
         return { success: false, error: result.error || 'Unknown error' };
     }
     spinner.succeed(`Removal of ${args.key} succeeded`);
-    return { success: true };
+    return { success: true, json: { name: args.name, key: args.key } };
 }

package/dist/cores/functions/test.js

@@ -138,7 +138,7 @@ export async function functionTestCore(options) {
                 event: 'scheduled',
             };
         const spinner = log.ora('Executing function...').start();
-        const { json, logs, error } = await testAction(resource, invokeOptions, contextOptions, {
+        const { json: response, logs, error, } = await testAction(resource, invokeOptions, contextOptions, {
             timeout: timeout ? timeout : resource.timeout,
         });
         if (error) {
@@ -151,11 +151,11 @@ export async function functionTestCore(options) {
         spinner.succeed('Function execution succeeded.');
         log('Logs:');
         log(logs || '');
-        if (json) {
+        if (response) {
             log('Response:');
-            log(JSON.stringify(json, null, 2));
+            log(JSON.stringify(response, null, 2));
         }
-        return { success: true };
+        return { success: true, json: { response, logs } };
     }
     catch (error) {
         return {

package/dist/cores/index.d.ts

@@ -7,7 +7,7 @@ export interface CoreConfig {
     /** The CLI binary name. */
     bin: string;
     /** The log output function. */
-    log: ReturnType<typeof Logger>;
+    log: Logger;
     /** Enable resource validation during parsing */
     validateResources?: boolean;
     /** Path to a specific Blueprint file or directory */
@@ -25,7 +25,10 @@ export interface DeployedBlueprintConfig extends BlueprintConfig {
     deployedStack: Stack;
 }
 export type CoreResult = {
-    /** Arbitrary data for isolated testing */
+    /**
+     * Internal data for isolated testing and debugging.
+     * Not returned to users! Use `json` for structured output via oclif's `--json` flag.
+     */
     data?: Record<string, unknown>;
 } & ({
     /** Something went wrong. */
@@ -40,6 +43,10 @@ export type CoreResult = {
     /** The streaming function, if the operation is streaming. */
     streaming?: Promise<void>;
     error?: never;
+    /**
+     * Structured data returned to the user when `--json` is passed.
+     * Commands should return this value from `run()` for oclif to serialize.
+     */
     json?: Record<string, unknown>;
 });
 type InitBlueprintConfigParams = CoreConfig & ({

package/dist/cores/index.js

@@ -1,7 +1,6 @@
 import { readLocalBlueprint } from '../actions/blueprints/blueprint.js';
 import { getStack, resolveStackIdByNameOrId } from '../actions/blueprints/stacks.js';
 import { presentBlueprintParserErrors } from '../utils/display/errors.js';
-import { niceId } from '../utils/display/presenters.js';
 import { validTokenOrErrorMessage } from '../utils/validated-token.js';
 export * as blueprintsCores from './blueprints/index.js';
 export * as functionsCores from './functions/index.js';
@@ -55,12 +54,14 @@ export async function initDeployedBlueprintConfig(config) {
         config.log(`Incomplete configuration. Run \`${config.bin} blueprints doctor\` for diagnostics.`);
         return { ok: false, error: 'Missing Stack deployment configuration for Blueprint' };
     }
+    const spinner = config.log.ora('Loading Stack deployment...').start();
     const stackResponse = await getStack({ stackId, auth, logger: config.log });
     if (!stackResponse.ok) {
-        config.log(`Could not retrieve Stack deployment info for ${niceId(stackId)}.`);
+        spinner.fail('Could not load Stack deployment');
         config.log(`Run \`${config.bin} blueprints doctor\` for diagnostics.`);
         return { ok: false, error: 'Missing Stack deployment' };
     }
+    spinner.stop().clear();
     return {
         ok: true,
         value: {

package/dist/server/app.d.ts

@@ -1,6 +1,6 @@
 import type { Logger } from '../utils/logger.js';
 import { type InvokeExecutionOptions } from '../utils/types.js';
-declare const app: (host: string, port: number, logger: ReturnType<typeof Logger>, validateResources: boolean, executionOptions?: Partial<InvokeExecutionOptions>) => void;
+declare const app: (host: string, port: number, logger: Logger, validateResources: boolean, executionOptions?: Partial<InvokeExecutionOptions>) => void;
 declare function parseDocumentUrl(url: string): {
     projectId: string;
     dataset: string;

package/dist/server/handlers/invoke.d.ts

@@ -1,5 +1,5 @@
 import type { Logger } from '../../utils/logger.js';
 import type { InvocationResponse, InvokeContextOptions, InvokeExecutionOptions, InvokePayloadMetadata } from '../../utils/types.js';
-export declare function handleInvokeRequest(functionName: string, event: Record<string, unknown>, metadata: InvokePayloadMetadata, context: InvokeContextOptions, logger: ReturnType<typeof Logger>, validateResources: boolean, executionOptions?: Partial<InvokeExecutionOptions>): Promise<InvocationResponse & {
+export declare function handleInvokeRequest(functionName: string, event: Record<string, unknown>, metadata: InvokePayloadMetadata, context: InvokeContextOptions, logger: Logger, validateResources: boolean, executionOptions?: Partial<InvokeExecutionOptions>): Promise<InvocationResponse & {
     timings: Record<string, number>;
 }>;

package/dist/utils/display/prompt.d.ts

@@ -10,7 +10,7 @@ export declare function promptForProject({ token, knownOrganizationId, knownProj
     token: string;
     knownOrganizationId?: string;
     knownProjectId?: string;
-    logger: ReturnType<typeof Logger>;
+    logger: Logger;
 }): Promise<{
     projectId: string;
     displayName: string;
@@ -26,7 +26,7 @@ export declare function promptForProject({ token, knownOrganizationId, knownProj
 export declare function promptForStack({ projectId, token, logger, }: {
     projectId: string;
     token: string;
-    logger: ReturnType<typeof Logger>;
+    logger: Logger;
 }): Promise<{
     stackId: string;
     name: string;

package/dist/utils/display/prompt.js

@@ -95,7 +95,7 @@ export async function promptForStack({ projectId, token, logger, }) {
         stackChoices.push({ name: styleText('bold', 'New Stack ✨'), value: NEW_STACK_ID });
         stackChoices.push(new Separator(styleText('underline', 'Use an existing Stack:')));
         stackChoices.push(...stacks.map((s) => ({
-            name: `"${s.name}" ${niceId(s.id)} ${styleText('dim', `(${s.resourceCount} res)`)}`,
+            name: `"${s.name}" ${niceId(s.id)} ${styleText('dim', `(${s.resourceCount} ${s.resourceCount === 1 ? 'resource' : 'resources'})`)}`,
             value: s.id,
         })));
         pickedStackId = await select({

package/dist/utils/display/resources-formatting.d.ts

@@ -1,7 +1,7 @@
 import type { BlueprintCorsOriginResource, BlueprintDatasetResource, BlueprintDocumentWebhookResource, BlueprintRobotResource, BlueprintRoleResource } from '@sanity/blueprints';
+import type { Resource } from '@sanity/blueprints-parser';
 import type { TreeInput } from 'array-treeify';
-import { type FunctionResourceBase } from '../../utils/types.js';
-export declare function arrayifyFunction(fn: FunctionResourceBase): TreeInput;
+export declare function arrayifyFunction(fn: Resource): TreeInput;
 export declare function arrayifyCors(resource: BlueprintCorsOriginResource): TreeInput;
 export declare function arrayifyRobot(resource: BlueprintRobotResource): TreeInput;
 export declare function arrayifyRole(resource: BlueprintRoleResource): TreeInput;

package/dist/utils/display/resources-formatting.js

@@ -1,4 +1,4 @@
-import { isScheduleEvent, } from '../../utils/types.js';
+import { isScheduleEvent } from '../../utils/types.js';
 import { styleText } from '../style-text.js';
 function formatLabel(label) {
     return styleText('dim', `${label}:`);

package/dist/utils/functions/fetch-document.d.ts

@@ -1,5 +1,5 @@
 import { type ClientConfig } from '@sanity/client';
 import type { Logger } from '../logger.js';
 import type { FetchConfig } from '../types.js';
-export declare function fetchDocument(documentId: string, { projectId, dataset, useCdn, apiVersion, apiHost, token }: ClientConfig, logger: ReturnType<typeof Logger>): Promise<Record<string, unknown>>;
-export declare function fetchAsset(documentId: string, { mediaLibraryId, apiVersion, apiHost, token }: FetchConfig, logger: ReturnType<typeof Logger>): Promise<Record<string, unknown>>;
+export declare function fetchDocument(documentId: string, { projectId, dataset, useCdn, apiVersion, apiHost, token }: ClientConfig, logger: Logger): Promise<Record<string, unknown>>;
+export declare function fetchAsset(documentId: string, { mediaLibraryId, apiVersion, apiHost, token }: FetchConfig, logger: Logger): Promise<Record<string, unknown>>;

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

@@ -1,11 +1,6 @@
-import type { CollectionFunction, FunctionResource, InstallerType } from '../types.js';
+import type { AssetPrepResult, FunctionResource, InstallerType } from '../types.js';
 export declare function prepareAsset({ resource, }: {
-    resource: FunctionResource | CollectionFunction;
+    resource: FunctionResource;
 }, { installer }?: {
     installer?: InstallerType;
-}): Promise<{
-    success: boolean;
-    outputPath?: string;
-    cleanup?: () => Promise<void>;
-    error?: string;
-}>;
+}): Promise<AssetPrepResult>;

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

@@ -29,7 +29,7 @@ export async function prepareAsset({ resource, }, { installer } = {}) {
             wasBundled = result.bundled;
         }
         catch (err) {
-            return { success: false, error: err instanceof Error ? err.message : `${err}` };
+            return { success: false, cleanup, error: err instanceof Error ? err.message : `${err}` };
         }
     }
     const shouldResolveDependencies = await shouldAutoResolveDependencies(resource);
@@ -45,7 +45,7 @@ export async function prepareAsset({ resource, }, { installer } = {}) {
         return { success: true, outputPath: functionPath, cleanup };
     }
     catch (err) {
-        return { success: false, error: err instanceof Error ? err.message : `${err}` };
+        return { success: false, cleanup, error: err instanceof Error ? err.message : `${err}` };
     }
 }
 /**

package/dist/utils/functions/should-auto-resolve-deps.js

@@ -1,5 +1,5 @@
 export async function shouldAutoResolveDependencies(resource) {
-    if (typeof resource.autoResolveDeps === 'boolean') {
+    if ('autoResolveDeps' in resource && typeof resource.autoResolveDeps === 'boolean') {
         return resource.autoResolveDeps;
     }
     // otherwise hydrate is the default

package/dist/utils/functions/should-transpile.js

@@ -1,6 +1,6 @@
 import { findFunctionEntryPoint } from './find-entry-point.js';
 export async function shouldTranspileFunction(resource) {
-    if (typeof resource.transpile === 'boolean') {
+    if ('transpile' in resource && typeof resource.transpile === 'boolean') {
         return resource.transpile;
     }
     if (!resource.src) {

package/dist/utils/invoke-local.d.ts

@@ -1,10 +1,4 @@
-import { type FunctionGroqResource, type FunctionResource, type GroqRuleBase, type InvocationResponse, type InvokeContextOptions, type InvokeExecutionOptions, type InvokeGroqPayloadOptions, type InvokePayloadOptions } from './types.js';
+import { type FunctionGroqResource, type FunctionResource, type InvocationResponse, type InvokeContextOptions, type InvokeExecutionOptions, type InvokeGroqPayloadOptions, type InvokePayloadOptions } from './types.js';
 export declare function sanitizeLogs(logs: string): string;
-export declare const DEFAULT_GROQ_RULE: {
-    on: string[];
-    filter: string;
-    projection: string;
-};
-export declare function isDefaultGROQRule(rule: GroqRuleBase | undefined): boolean;
 export declare function applyGroqRule(resource: FunctionGroqResource, payload: InvokeGroqPayloadOptions, projectId: string | undefined, dataset: string | undefined): Promise<any>;
 export default function invoke(resource: FunctionResource, payload: InvokePayloadOptions, context: InvokeContextOptions, options: InvokeExecutionOptions): Promise<InvocationResponse>;