@sanity/runtime-cli 17.12.0 → 17.13.0-next.g06897b0

package/dist/server/static/web-socket.js

@@ -2,8 +2,10 @@ import apiConstructor from '../api.js'
 
 const api = apiConstructor()
 
-// Create WebSocket connection.
-const socket = new WebSocket('ws://localhost:8974')
+// Create WebSocket connection on the same origin the emulator is served from,
+// so it follows the --host and --port the server was started with.
+const protocol = window.location.protocol === 'https:' ? 'wss:' : 'ws:'
+const socket = new WebSocket(`${protocol}//${window.location.host}`)
 
 // Connection opened
 socket.addEventListener('open', () => {

package/dist/utils/blueprints/deploy-metadata.d.ts

@@ -0,0 +1,10 @@
+/**
+ * Facts about the environment that runs a deploy.
+ * Sent as the `client` part of deploy metadata. Keys with an `undefined` value drop out of the JSON body.
+ */
+export declare function getClientMetadata({ cliVersion, dir, }: {
+    /** Version of the CLI that hosts this plugin, when known */
+    cliVersion?: string;
+    /** Directory of the Blueprint file, used to detect the package manager */
+    dir: string;
+}): Record<string, unknown>;

package/dist/utils/blueprints/deploy-metadata.js

@@ -0,0 +1,17 @@
+import { platform, versions } from 'node:process';
+import config, { RUNTIME_CLI_VERSION } from '../../config.js';
+import { detectPackageManager } from '../package-manager.js';
+/**
+ * Facts about the environment that runs a deploy.
+ * Sent as the `client` part of deploy metadata. Keys with an `undefined` value drop out of the JSON body.
+ */
+export function getClientMetadata({ cliVersion, dir, }) {
+    return {
+        cliVersion,
+        runtimeCliVersion: RUNTIME_CLI_VERSION,
+        nodeVersion: versions.node,
+        nodePackageManager: detectPackageManager(dir),
+        platform,
+        ci: config.isCi,
+    };
+}

package/dist/utils/blueprints/resolve-deployed-resources.d.ts

@@ -1,11 +1,10 @@
 import type { BlueprintResource } from '@sanity/blueprints';
-import type { Logger } from '../logger.js';
 import type { AuthParams } from '../types.js';
 interface ResolveOptions {
     resources: BlueprintResource[];
     stackId?: string;
     auth?: AuthParams;
-    logger: Logger;
+    fetchFn: typeof fetch;
 }
 /**
  * Returns the local blueprint resources, annotated with externalIds from the
@@ -13,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, logger, }: ResolveOptions): Promise<BlueprintResource[]>;
+export declare function resolveDeployedResources({ resources, stackId, auth, fetchFn, }: ResolveOptions): Promise<BlueprintResource[]>;
 export {};

package/dist/utils/blueprints/resolve-deployed-resources.js

@@ -5,11 +5,11 @@ import { getStack } from '../../actions/blueprints/stacks.js';
  * 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 async function resolveDeployedResources({ resources, stackId, auth, logger, }) {
+export async function resolveDeployedResources({ resources, stackId, auth, fetchFn, }) {
     if (!stackId || !auth?.token || !auth.scopeType || !auth.scopeId)
         return resources;
     try {
-        const response = await getStack({ stackId, auth, logger });
+        const response = await getStack({ stackId, auth, fetchFn });
         if (!response.ok || !Array.isArray(response.stack?.resources))
             return resources;
         const deployedByKey = new Map();

package/dist/utils/blueprints/wait-for.d.ts

@@ -0,0 +1,60 @@
+import type { Logger } from '../logger.js';
+import type { BlueprintLog } from '../types.js';
+/** Delay before the first operation poll. Override with SANITY_OPERATION_POLL_INITIAL_DELAY_MS. */
+export declare const OPERATION_POLL_INITIAL_DELAY_MS: number;
+/** Interval between operation status polls. Override with SANITY_OPERATION_POLL_INTERVAL_MS. */
+export declare const OPERATION_POLL_INTERVAL_MS: number;
+/** Consecutive failed polls tolerated before giving up on confirming status. */
+export declare const OPERATION_POLL_MAX_CONSECUTIVE_ERRORS = 5;
+/** Result of waiting for a deploy/destroy operation to settle. */
+export type OperationOutcome = {
+    type: 'completed';
+} | {
+    type: 'failed';
+    logHints: string[];
+} | {
+    type: 'unconfirmed';
+    error?: string;
+};
+type EndState = 'completed' | 'failed';
+export type StateInfo = {
+    state: EndState;
+} | {
+    state: 'pending';
+    /** Used to avoid repeatedly outputting pending status messages. */
+    latestStatus: string;
+    verboseMessage: string;
+} | {
+    state: 'not_found';
+    verboseError: string;
+} | {
+    state: 'error';
+    error: string | null;
+    verboseError: string;
+};
+type WaitForOptions = {
+    /**
+     * Requests the latest state and returns it to the main loop for processing.
+     * @returns The current state of the thing we are waiting for
+     */
+    onRequestLatestState: () => Promise<StateInfo>;
+    /**
+     * Called when the waitFor logic should start reading logs.
+     * @returns A function that stops the polling process when invoked.
+     */
+    onStartLogPolling: (options: {
+        onActivity?: () => void;
+        onLogEntry?: (log: BlueprintLog, previousLog: BlueprintLog | undefined) => void;
+    }) => () => void;
+    getIdleMessage: () => string;
+};
+export type WaitForFn = (options: WaitForOptions) => Promise<OperationOutcome>;
+export declare function createWaitFor({ bin, log, verbose, initialDelayMs, pollIntervalMs, idleSpinnerDelayMs, }: {
+    bin: string;
+    log: Logger;
+    verbose?: boolean;
+    initialDelayMs?: number;
+    pollIntervalMs?: number;
+    idleSpinnerDelayMs?: number;
+}): WaitForFn;
+export {};

package/dist/utils/blueprints/wait-for.js

@@ -0,0 +1,115 @@
+import { setTimeout as sleep } from 'node:timers/promises';
+import { formatLogEntry } from '../display/logs-formatting.js';
+import { runCommand } from '../package-manager.js';
+import { createHintCollector } from './hints.js';
+const envMs = (value, fallback) => {
+    if (!value)
+        return fallback;
+    const parsed = Number(value);
+    return Number.isFinite(parsed) && parsed >= 0 ? parsed : fallback;
+};
+/** Delay before the first operation poll. Override with SANITY_OPERATION_POLL_INITIAL_DELAY_MS. */
+export const OPERATION_POLL_INITIAL_DELAY_MS = envMs(process.env.SANITY_OPERATION_POLL_INITIAL_DELAY_MS, 1000);
+/** Interval between operation status polls. Override with SANITY_OPERATION_POLL_INTERVAL_MS. */
+export const OPERATION_POLL_INTERVAL_MS = envMs(process.env.SANITY_OPERATION_POLL_INTERVAL_MS, 1500);
+/** Consecutive failed polls tolerated before giving up on confirming status. */
+export const OPERATION_POLL_MAX_CONSECUTIVE_ERRORS = 5;
+const IDLE_SPINNER_DELAY_MS = 30_000;
+const IDLE_SPINNER_UPDATE_INTERVAL_MS = 15_000;
+export function createWaitFor({ bin, log, verbose, initialDelayMs = OPERATION_POLL_INITIAL_DELAY_MS, pollIntervalMs = OPERATION_POLL_INTERVAL_MS, idleSpinnerDelayMs = IDLE_SPINNER_DELAY_MS, }) {
+    return async (options) => {
+        const logHints = createHintCollector(bin);
+        let logStreamCleanup = null;
+        let idleSpinner;
+        const stopIdleSpinner = (restoreOperationProgress = false) => {
+            if (!idleSpinner)
+                return;
+            idleSpinner.stop();
+            idleSpinner = undefined;
+            if (restoreOperationProgress)
+                log.showProgress();
+        };
+        try {
+            log.showProgress();
+            let lastLogAt = Date.now();
+            let nextIdleSpinnerUpdateAt = idleSpinnerDelayMs;
+            let consecutiveErrors = 0;
+            let lastStatus;
+            logStreamCleanup = options.onStartLogPolling({
+                onActivity: () => {
+                    lastLogAt = Date.now();
+                    nextIdleSpinnerUpdateAt = idleSpinnerDelayMs;
+                    stopIdleSpinner(true);
+                },
+                onLogEntry: (logEntry, previousLog) => {
+                    logHints.inspectLog(logEntry);
+                    log(formatLogEntry(logEntry, verbose, previousLog));
+                },
+            });
+            // balk in case read replica lags
+            await sleep(initialDelayMs);
+            while (true) {
+                const stateInfo = await options.onRequestLatestState();
+                if (stateInfo.state === 'completed') {
+                    if (logStreamCleanup)
+                        logStreamCleanup();
+                    stopIdleSpinner();
+                    log('');
+                    return { type: 'completed' };
+                }
+                if (stateInfo.state === 'failed') {
+                    if (logStreamCleanup)
+                        logStreamCleanup();
+                    stopIdleSpinner();
+                    log('');
+                    return { type: 'failed', logHints: logHints.getSuggestions() };
+                }
+                // tolerate a few consecutive errors; the operation was accepted and may still be running
+                if (stateInfo.state === 'error') {
+                    consecutiveErrors += 1;
+                    log.verbose(`${stateInfo.verboseError}; retrying (${consecutiveErrors}/${OPERATION_POLL_MAX_CONSECUTIVE_ERRORS}).`);
+                    if (consecutiveErrors >= OPERATION_POLL_MAX_CONSECUTIVE_ERRORS) {
+                        if (logStreamCleanup)
+                            logStreamCleanup();
+                        stopIdleSpinner();
+                        log('');
+                        return { type: 'unconfirmed', error: stateInfo.error ?? undefined };
+                    }
+                }
+                else {
+                    consecutiveErrors = 0;
+                    if (stateInfo.state === 'not_found') {
+                        log.verbose(stateInfo.verboseError);
+                    }
+                    else if (stateInfo.state === 'pending' && stateInfo.latestStatus !== lastStatus) {
+                        log.verbose(stateInfo.verboseMessage);
+                        lastStatus = stateInfo.latestStatus;
+                    }
+                }
+                const idleFor = Date.now() - lastLogAt;
+                if (idleFor >= nextIdleSpinnerUpdateAt) {
+                    const elapsedIdleMs = idleSpinnerDelayMs +
+                        Math.floor((idleFor - idleSpinnerDelayMs) / IDLE_SPINNER_UPDATE_INTERVAL_MS) *
+                            IDLE_SPINNER_UPDATE_INTERVAL_MS;
+                    const elapsedIdleSeconds = elapsedIdleMs / 1000;
+                    const text = `No new activity for ${elapsedIdleSeconds} seconds. ${options.getIdleMessage()} You can safely exit and check status later with \`${runCommand(bin)} blueprints info\`.`;
+                    if (idleSpinner)
+                        idleSpinner.start(text);
+                    else
+                        idleSpinner = log.ora(text).start();
+                    nextIdleSpinnerUpdateAt = elapsedIdleMs + IDLE_SPINNER_UPDATE_INTERVAL_MS;
+                }
+                await sleep(pollIntervalMs);
+            }
+        }
+        catch (error) {
+            if (logStreamCleanup)
+                logStreamCleanup();
+            throw error;
+        }
+        finally {
+            stopIdleSpinner();
+            log.clearProgress();
+        }
+    };
+}

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

@@ -4,6 +4,7 @@ import type { DeploymentPlan } from '../../actions/blueprints/stacks.js';
 import { type BlueprintResourceRecord, type Stack, type StackSummary } from '../types.js';
 export declare function formatTitle(title: string, name: string): string;
 export declare function formatDeployedResourceTree(resources: BlueprintResourceRecord[] | undefined, verbose?: boolean): string;
+export declare function formatStudioUrls(resources: BlueprintResourceRecord[] | undefined): string[];
 export declare function formatResourceTree(resources: BlueprintResource[] | undefined, verbose?: boolean): string;
 export declare function formatStackInfo(stack: Stack | StackSummary | Blueprint, isCurrentStack?: boolean): string;
 export declare function formatStacksListing(stacks: StackSummary[], currentStackId?: string): string;

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

@@ -1,10 +1,10 @@
+import { formatDateTime, formatElapsed } from '@sanity/cli-core/dates';
 import { treeify } from 'array-treeify';
 import { SANITY_ACCESS_ROBOT, SANITY_ACCESS_ROLE, SANITY_FUNCTION_DOCUMENT, SANITY_FUNCTION_DURABLE, SANITY_FUNCTION_MEDIA_LIBRARY_ASSET, SANITY_FUNCTION_PUBSUB, SANITY_FUNCTION_SCHEDULED, SANITY_FUNCTION_SYNC_TAG_INVALIDATE, SANITY_PROJECT, SANITY_PROJECT_CORS, SANITY_PROJECT_DATASET, SANITY_PROJECT_WEBHOOK, SANITY_STUDIO, } from '../../constants.js';
 import { styleText } from '../style-text.js';
 import { isCorsOriginResource, isDatasetResource, isRobotResource, isRoleResource, isStudioResource, isWebhookResource, } from '../types.js';
-import { formatDateTime, formatDuration } from './dates.js';
 import { capitalize, niceId, renderSection } from './presenters.js';
-import { arrayifyCors, arrayifyDataset, arrayifyFunction, arrayifyRobot, arrayifyRole, arrayifyStudio, arrayifyWebhook, } from './resources-formatting.js';
+import { arrayifyCors, arrayifyDataset, arrayifyFunction, arrayifyRobot, arrayifyRole, arrayifyStudio, arrayifyWebhook, studioHost, studioUrl, } from './resources-formatting.js';
 const functionCategory = {
     label: 'Functions',
     displayNameAttribute: 'displayName',
@@ -165,6 +165,19 @@ export function formatDeployedResourceTree(resources, verbose = false) {
     (res) => ({ name: res.name, type: res.type, ...(res.resolvedParameters ?? res.parameters) }), verbose);
     return `${treeify(output)}\n`;
 }
+export function formatStudioUrls(resources) {
+    if (!resources)
+        return [];
+    const lines = [];
+    for (const res of resources) {
+        if (res.type !== SANITY_STUDIO)
+            continue;
+        const host = studioHost(res.resolvedParameters ?? res.parameters);
+        if (host)
+            lines.push(`Studio ${styleText(['bold', 'green'], res.name)} ${studioUrl(host)}`);
+    }
+    return lines;
+}
 export function formatResourceTree(resources, verbose = false) {
     if (!resources || resources.length === 0)
         return '  Zero resources';
@@ -207,7 +220,8 @@ export function formatStackInfo(stack, isCurrentStack = false) {
         if (time)
             parts.push(styleText('dim', formatDateTime(time)));
         if (op.completedAt && op.createdAt) {
-            parts.push(styleText('yellow', `(${formatDuration(op.createdAt, op.completedAt)})`));
+            const duration = new Date(op.completedAt).getTime() - new Date(op.createdAt).getTime();
+            parts.push(styleText('yellow', `(${formatElapsed(duration)})`));
         }
         rows.push(['Operation', parts.join('  ')]);
         if (op.userMessage)

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

@@ -1,6 +1,4 @@
 type DateInput = string | number | Date;
 export declare function formatDate(input: DateInput): string;
 export declare function formatTime(input: DateInput): string;
-export declare function formatDateTime(input: DateInput): string;
-export declare function formatDuration(startDate: string, endDate: string): string;
 export {};

package/dist/utils/display/dates.js

@@ -19,28 +19,3 @@ export function formatTime(input) {
     const s = String(d.getSeconds()).padStart(2, '0');
     return `${h}:${m}:${s}`;
 }
-export function formatDateTime(input) {
-    const d = toDate(input);
-    if (Number.isNaN(d.getTime()))
-        return '';
-    return `${formatDate(d)} ${formatTime(d)}`;
-}
-export function formatDuration(startDate, endDate) {
-    const start = new Date(startDate).getTime();
-    const end = new Date(endDate).getTime();
-    if (start > end)
-        return 'Invalid duration';
-    const durationMs = end - start;
-    if (durationMs < 1000)
-        return `${durationMs}ms`;
-    if (durationMs < 60000)
-        return `${Math.round(durationMs / 1000)}s`;
-    if (durationMs < 3600000) {
-        const minutes = Math.floor(durationMs / 60000);
-        const seconds = Math.floor((durationMs % 60000) / 1000);
-        return `${minutes}m ${seconds}s`;
-    }
-    const hours = Math.floor(durationMs / 3600000);
-    const minutes = Math.floor((durationMs % 3600000) / 60000);
-    return `${hours}h ${minutes}m`;
-}

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

@@ -1,6 +1,6 @@
+import { formatDateTime } from '@sanity/cli-core/dates';
 import { SANITY_FUNCTION_PREFIX } from '../../constants.js';
 import { styleText } from '../style-text.js';
-import { formatDateTime } from './dates.js';
 import { niceId, renderSection } from './presenters.js';
 export function formatFunctionsList(functions, options = {}) {
     if (!options.verbose)

package/dist/utils/display/prompt.js

@@ -1,10 +1,13 @@
 import { confirm, input, Separator, select } from '@inquirer/prompts';
 import { createEmptyStack, listStacks } from '../../actions/blueprints/stacks.js';
 import { groupProjectsByOrganization } from '../../actions/sanity/projects.js';
+import { STACKS_DOCS_URL } from '../../constants.js';
 import { styleText } from '../style-text.js';
 import { niceId } from './presenters.js';
 // --- Wizard infrastructure ---
 export const BACK = Symbol('back');
+/** Shown under the highlighted Stack choice; a printed line would break the wizard's two-line erase on Back */
+const STACK_DEFINITION = `A Stack is the deployed copy of a Blueprint: the live resources on Sanity's side. ${STACKS_DOCS_URL}`;
 /** Thrown when the user picks "Cancel" in a prompt. Cores translate it to a clean result. */
 export class CancelledError extends Error {
     constructor(message = 'Cancelled by user.') {
@@ -270,7 +273,7 @@ export async function promptForStack({ scopeType, scopeId, token, logger, allowB
     if (stacks.length > 0) {
         const stackChoices = [
             new Separator(styleText('underline', 'Create a new Stack:')),
-            { name: styleText('bold', 'New Stack'), value: NEW_STACK_ID },
+            { name: styleText('bold', 'New Stack'), value: NEW_STACK_ID, description: STACK_DEFINITION },
             new Separator(styleText('underline', 'Use an existing Stack:')),
             ...stacks.map((s) => ({
                 name: `"${s.name}" ${niceId(s.id)} ${styleText('dim', `(${s.resourceCount} ${s.resourceCount === 1 ? 'resource' : 'resources'})`)}`,
@@ -301,7 +304,7 @@ export async function promptForStack({ scopeType, scopeId, token, logger, allowB
                 {
                     name: 'Create the first Stack',
                     value: NEW_STACK_ID,
-                    description: 'A Blueprint needs a Stack before it can deploy',
+                    description: STACK_DEFINITION,
                 },
                 { name: 'Cancel', value: CANCEL, description: 'Stop here and change nothing' },
             ], allowBack),

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

@@ -5,5 +5,11 @@ export declare function arrayifyDataset(resource: BlueprintDatasetResource): Tre
 export declare function arrayifyFunction(fn: BlueprintResource): TreeInput;
 export declare function arrayifyRobot(resource: BlueprintRobotResource): TreeInput;
 export declare function arrayifyRole(resource: BlueprintRoleResource): TreeInput;
+/**
+ * Hostname label of a Studio: the resolved `appHost` when present, else the authored `slug`.
+ * undefined when a `$.resources` reference
+ */
+export declare function studioHost(params: Record<string, unknown>): string | undefined;
+export declare function studioUrl(host: string): string;
 export declare function arrayifyStudio(resource: BlueprintStudioResource): TreeInput;
 export declare function arrayifyWebhook(resource: BlueprintDocumentWebhookResource): TreeInput;

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

@@ -1,3 +1,4 @@
+import config from '../../config.js';
 import { hasEventSource, isLocalFunctionResource, isScheduleEvent, } from '../../utils/types.js';
 import { styleText } from '../style-text.js';
 import { niceId } from './presenters.js';
@@ -120,8 +121,24 @@ export function arrayifyRole(resource) {
     }
     return details;
 }
+/**
+ * Hostname label of a Studio: the resolved `appHost` when present, else the authored `slug`.
+ * undefined when a `$.resources` reference
+ */
+export function studioHost(params) {
+    const host = params.appHost ?? params.slug;
+    if (typeof host !== 'string' || host.length === 0 || host.startsWith('$.'))
+        return undefined;
+    return host;
+}
+export function studioUrl(host) {
+    return `https://${host}.${config.studioDomain}`;
+}
 export function arrayifyStudio(resource) {
     const details = [formatLabeledValue('appHost', resource.slug)];
+    const host = studioHost(resource);
+    if (host)
+        details.push(formatLabeledValue('url', studioUrl(host)));
     if (resource.project)
         details.push(formatLabeledValue('project', niceId(resource.project)));
     return details;

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

@@ -107,13 +107,13 @@ export async function runDurable(handler, {context, event}, io) {
         }
         return state
       }),
-    delegate: ({name, handler, input}) =>
+    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, input)
+        return io.invoke(fn, event)
       }),
   }
 

package/dist/utils/functions/dependency-info.d.ts

@@ -0,0 +1,30 @@
+/** Where a function's dependency list came from. */
+export type DependencySource = 'manifest' | 'autoinstall' | 'bundled' | 'none';
+export type DependencyInfo = {
+    dependencySource: DependencySource;
+    dependencyCount: number;
+    /** Declared versions */
+    dependencies?: Record<string, string>;
+    /** Source files the Arc treeshaker parsed - autoinstall only */
+    parsedFileCount?: number;
+};
+/** The package.json Architect generates during autoinstall. */
+export type AutoInstallManifest = {
+    dependencies?: Record<string, string>;
+    _parsed?: string[];
+};
+/**
+ * Read and delete the manifest Architect generated during autoinstall.
+ * Arc moves it to `node_modules/_arc-autoinstall/` after the install.
+ * Has a timestamp, so it must be deleted to avoid hash changes on every deploy.
+ */
+export declare function takeAutoInstallManifest(installDir: string): Promise<AutoInstallManifest | undefined>;
+/**
+ * Describe a function's dependencies from the manifest that declared them.
+ * The user's own package.json wins. Otherwise the Architect autoinstall manifest is used.
+ */
+export declare function getDependencyInfo({ sourceDir, autoInstall, bundled, }: {
+    sourceDir: string;
+    autoInstall?: AutoInstallManifest;
+    bundled: boolean;
+}): Promise<DependencyInfo>;

package/dist/utils/functions/dependency-info.js

@@ -0,0 +1,57 @@
+import { readFile, rm } from 'node:fs/promises';
+import path from 'node:path';
+/**
+ * Read and delete the manifest Architect generated during autoinstall.
+ * Arc moves it to `node_modules/_arc-autoinstall/` after the install.
+ * Has a timestamp, so it must be deleted to avoid hash changes on every deploy.
+ */
+export async function takeAutoInstallManifest(installDir) {
+    const file = path.join(installDir, 'node_modules', '_arc-autoinstall', 'package.json');
+    let manifest;
+    try {
+        manifest = JSON.parse(await readFile(file, 'utf8'));
+    }
+    catch {
+        // no autoinstall happened, or the file is unreadable
+    }
+    try {
+        await rm(file, { force: true });
+    }
+    catch {
+        // best effort
+    }
+    return manifest;
+}
+/**
+ * Describe a function's dependencies from the manifest that declared them.
+ * The user's own package.json wins. Otherwise the Architect autoinstall manifest is used.
+ */
+export async function getDependencyInfo({ sourceDir, autoInstall, bundled, }) {
+    const declared = await readDeclaredDependencies(sourceDir);
+    if (declared && Object.keys(declared).length > 0) {
+        return {
+            dependencySource: 'manifest',
+            dependencyCount: Object.keys(declared).length,
+            dependencies: declared,
+        };
+    }
+    if (autoInstall) {
+        const dependencies = autoInstall.dependencies ?? {};
+        return {
+            dependencySource: 'autoinstall',
+            dependencyCount: Object.keys(dependencies).length,
+            dependencies,
+            parsedFileCount: autoInstall._parsed?.length,
+        };
+    }
+    return { dependencySource: bundled ? 'bundled' : 'none', dependencyCount: 0 };
+}
+async function readDeclaredDependencies(dir) {
+    try {
+        const pkg = JSON.parse(await readFile(path.join(dir, 'package.json'), 'utf8'));
+        return pkg.dependencies;
+    }
+    catch {
+        return undefined;
+    }
+}

package/dist/utils/functions/invoke/assert-console.d.ts

@@ -0,0 +1,5 @@
+/**
+ * Asserts that a given source file does not contain any `console` usage.
+ * @param src
+ */
+export declare const assertConsole: (src: string) => void;

package/dist/utils/functions/invoke/assert-console.js

@@ -0,0 +1,60 @@
+import { existsSync, readFileSync } from 'node:fs';
+import { dirname, extname, resolve } from 'node:path';
+import { parseSync, Visitor } from 'vite';
+const EXTENSIONS = ['', '.ts', '.js', '.mjs', '.cjs'];
+/**
+ * Resolves a local module if it exists.
+ * @param fromFile
+ * @param specifier
+ */
+const resolveLocalModule = (fromFile, specifier) => {
+    const base = resolve(dirname(fromFile), specifier);
+    const candidates = [
+        base,
+        base.replace(/\.js$/, '.ts'),
+        ...EXTENSIONS.map((ext) => base + ext),
+        ...EXTENSIONS.map((ext) => resolve(base, `index${ext}`)),
+    ];
+    return candidates.find((candidate) => EXTENSIONS.includes(extname(candidate)) && existsSync(candidate) && !candidate.endsWith('/'));
+};
+/**
+ * Asserts that a given source file does not contain any `console` usage.
+ * @param src
+ */
+export const assertConsole = (src) => {
+    const seen = new Set();
+    const stack = [src];
+    while (stack.length > 0) {
+        const file = stack.pop();
+        if (!file || seen.has(file)) {
+            continue;
+        }
+        seen.add(file);
+        const { program, module: esm, errors } = parseSync(file, readFileSync(file, 'utf8'));
+        if (errors.length > 0) {
+            throw new Error(`Failed to parse ${file}: ${errors.map((e) => e.message).join(', ')}`);
+        }
+        new Visitor({
+            MemberExpression(node) {
+                if (node.object.type === 'Identifier' && node.object.name === 'console') {
+                    // @todo: improve error message to include doc link.
+                    const err = new Error('Console logging is not allowed in Durable functions. ' +
+                        `at ${file} ` +
+                        'Use the provided durable logger `logger.log()` or `ctx.log()` instead.');
+                    err.stack = undefined;
+                    throw err;
+                }
+            },
+        }).visit(program);
+        const isLocal = (str) => str.startsWith('./') || str.startsWith('../');
+        const imports = esm.staticImports.map((item) => item.moduleRequest.value);
+        const reExports = esm.staticExports.flatMap((exp) => exp.entries.flatMap((entry) => entry.moduleRequest && !entry.isType ? [entry.moduleRequest.value] : []));
+        const specs = [...imports, ...reExports].filter(isLocal);
+        for (const spec of specs) {
+            const resolved = resolveLocalModule(file, spec);
+            if (resolved) {
+                stack.push(resolved);
+            }
+        }
+    }
+};

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

@@ -1,4 +1,5 @@
 import { spawn } from 'node:child_process';
+import { resolve } from 'node:path';
 import { performance } from 'node:perf_hooks';
 import { cwd } from 'node:process';
 import { setTimeout } from 'node:timers';
@@ -8,6 +9,8 @@ import config from '../../../config.js';
 import { SANITY_FUNCTION_DURABLE } from '../../../constants.js';
 import { groupBlueprintResources } from '../../blueprints/group-resources.js';
 import { isGroqContextOptions, } from '../../types.js';
+import { findFunctionEntryPoint } from '../find-entry-point.js';
+import { assertConsole } from './assert-console.js';
 import { acquireFunctionBuild } from './prepare.js';
 import { isGroqInvocation } from './resolve-invoke-type.js';
 function getChildProcessWrapperPath() {
@@ -48,6 +51,12 @@ export default async function invoke(resource, payload, context, options) {
         throw new Error(`Function resource "${resource.name}" is missing the 'src' property.`);
     }
     const { forceColor = true, timeout = 10, onNestedInvoke, depth = 0, callStack = [], onStepEvent = () => { }, noWait = false, } = options;
+    // Ensure a user when running a durable is using the provided logger and not the `console`
+    if (resource.type === SANITY_FUNCTION_DURABLE) {
+        const sourcePath = resolve(context.blueprintFileDir, resource.src);
+        const entry = await findFunctionEntryPoint(sourcePath, resource?.displayName || resource.name);
+        assertConsole(entry);
+    }
     // `payload.payload` is the event body for every function type: the document for
     // GROQ-based events, whatever the producer sent for the rest. The handler always
     // receives it as `event.data` (see the `payload` built in `start()` below).

package/dist/utils/functions/is-folder-larger-than.d.ts

@@ -0,0 +1,5 @@
+import { type PathLike } from 'node:fs';
+/**
+ * Recursively validates the total size of a folder, including all nested files and subdirectories.
+ */
+export declare function isFolderLargerThan(folder: PathLike, maxBytes: number): boolean;