@sanity/runtime-cli 16.0.3 → 17.1.0

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

@@ -0,0 +1,41 @@
+import apiConstructor from '../api.js'
+
+const api = apiConstructor()
+
+// Create WebSocket connection.
+const socket = new WebSocket('ws://localhost:8974')
+
+// Connection opened
+socket.addEventListener('open', () => {
+  console.log('Watching for Blueprint changes')
+})
+
+// Listen for messages
+socket.addEventListener('message', (event) => {
+  if (event.data === 'reload-blueprint') {
+    api.blueprint()
+    return
+  }
+
+  let message
+  try {
+    message = JSON.parse(event.data)
+  } catch {
+    return
+  }
+
+  if (message?.type === 'nested-invoke') {
+    window.dispatchEvent(
+      new CustomEvent('nested-invoke', {
+        detail: {
+          name: message.name,
+          order: message.order,
+          logs: message.logs,
+          json: message.json,
+          error: message.error,
+          timings: message.timings,
+        },
+      }),
+    )
+  }
+})

package/dist/utils/functions/child-process-wrapper.js

@@ -76,7 +76,34 @@ console.error = (...args) => {
   process.stdout.write(`${logPrefix('error', ...args)}\n`)
 }
 
-// Start when payload data arrives from parent process
+/**
+ * Pending nested `context.invoke` calls, keyed by correlation id. Each entry
+ * holds the resolve/reject of the Promise returned to the user's handler; it is
+ * settled when the matching `invoke-response` arrives from the parent.
+ * @type {Map<string, {resolve: (value: unknown) => void, reject: (reason: Error) => void}>}
+ */
+const pendingInvokes = new Map()
+let invokeSeq = 0
+
+/**
+ * `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.
+ * @param {string} name
+ * @param {Record<string, unknown>} [payload]
+ * @returns {Promise<unknown>}
+ */
+function invokeFunction(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) => {
+    pendingInvokes.set(id, {resolve, reject})
+    process.send(JSON.stringify({type: 'invoke-request', id, name, payload}))
+  })
+}
+
+// Listen for IPC messages from the parent process.
 process.on('message', async (data) => {
   let jsonData = null
   try {
@@ -86,6 +113,25 @@ process.on('message', async (data) => {
     return
   }
 
+  // Response to a nested context.invoke() — route to the awaiting Promise and stop.
+  if (jsonData?.type === 'invoke-response') {
+    const pending = pendingInvokes.get(jsonData.id)
+    if (!pending) return
+    pendingInvokes.delete(jsonData.id)
+    if (jsonData.ok) {
+      pending.resolve(jsonData.result?.json)
+    } else {
+      const {message, stack, name} = jsonData.error ?? {}
+      const error = new Error(message ?? 'Nested invoke failed')
+      if (stack) error.stack = stack
+      if (name) error.name = name
+      pending.reject(error)
+    }
+    return
+  }
+
+  // Otherwise this is the initial start message. Support the legacy untyped
+  // `{srcPath, payload}` shape as well as the new `{type: 'start', ...}`.
   const {srcPath, payload} = jsonData
   const {context, ...event} = payload
 
@@ -93,17 +139,22 @@ process.on('message', async (data) => {
   let errorLogs = ''
   let json = null
 
-  // Capture stdout and stderr
+  // Capture stdout and stderr in-memory for the terminal `result` message, and
+  // ALSO send them through to the real stdio pipes. The parent captures those
+  // pipes live, so logs written before a timeout (child killed) or a
+  // process.exit() aren't lost
   const originalStdoutWrite = process.stdout.write.bind(process.stdout)
   const originalStderrWrite = process.stderr.write.bind(process.stderr)
 
-  process.stdout.write = (chunk) => {
+  process.stdout.write = (...args) => {
+    const chunk = args[0]
     if (typeof chunk === 'string') logs += chunk
-    return true
+    return originalStdoutWrite(...args)
   }
-  process.stderr.write = (chunk) => {
+  process.stderr.write = (...args) => {
+    const chunk = args[0]
     if (typeof chunk === 'string') errorLogs += chunk
-    return true
+    return originalStderrWrite(...args)
   }
 
   try {
@@ -120,6 +171,9 @@ process.on('message', async (data) => {
     // Replace resources JSON with Resources API
     context.resources = createResourcesApi(context.resources)
 
+    // Allow the handler to invoke other blueprint functions by name.
+    context.invoke = invokeFunction
+
     json = await eventHandler({
       context,
       event,
@@ -132,13 +186,14 @@ process.on('message', async (data) => {
     process.stderr.write = originalStderrWrite
 
     // Send result to parent
-    process.send(JSON.stringify({json, logs, errorLogs}))
+    process.send(JSON.stringify({type: 'result', json, logs, errorLogs}))
   } catch (err) {
     // Restore streams on error
     process.stdout.write = originalStdoutWrite
     process.stderr.write = originalStderrWrite
 
     const errorInfo = {
+      type: 'result',
       json: null,
       logs,
       errorLogs,

package/dist/utils/functions/{invoke-local.d.ts → invoke/local.d.ts}

@@ -1,4 +1,4 @@
-import { type FunctionGroqResource, type FunctionResource, 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 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>;

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

@@ -0,0 +1,306 @@
+import { spawn } from 'node:child_process';
+import { performance } from 'node:perf_hooks';
+import { cwd } from 'node:process';
+import { setTimeout } from 'node:timers';
+import { fileURLToPath } from 'node:url';
+import * as groq from 'groq-js';
+import config from '../../../config.js';
+import { groupBlueprintResources } from '../../blueprints/group-resources.js';
+import { isGroqContextOptions, } from '../../types.js';
+import { acquireFunctionBuild } from './prepare.js';
+function getChildProcessWrapperPath() {
+    return fileURLToPath(new URL('../child-process-wrapper.js', import.meta.url));
+}
+export function sanitizeLogs(logs) {
+    return logs.replace(/([a-zA-Z0-9]{10})[a-zA-Z0-9]{65,}/g, '$1**********');
+}
+export async function applyGroqRule(resource, payload, projectId, dataset) {
+    const { before, after, payload: data = null } = payload;
+    // If there is no rule set return everything
+    if (!resource.event)
+        return data;
+    // default groq rule is: gimme full doc content. otherwise, parse + eval custom rule
+    // applying the GROQ filter may result in a slimmer set of documents
+    if (resource.event.filter || resource.event.projection) {
+        const query = `*[${resource.event.filter || ''}]${resource.event.projection || ''}`;
+        try {
+            const rule = groq.parse(query, { mode: 'delta' });
+            const sanity = projectId && dataset ? { projectId, dataset } : undefined;
+            const queryResults = await groq.evaluate(rule, { dataset: [data], before, after, sanity });
+            const currentFunctionDocumentSet = await queryResults.get();
+            return currentFunctionDocumentSet[0];
+        }
+        catch (groqErr) {
+            const detail = groqErr instanceof Error && `; ${groqErr.message}`;
+            throw new Error(`Invalid rule configuration: ${query}${detail}`, { cause: groqErr });
+        }
+    }
+    // default groq rule so just return the data
+    return data;
+}
+export default async function invoke(resource, payload, context, options) {
+    if (!resource.src) {
+        throw new Error(`Function resource "${resource.name}" is missing the 'src' property.`);
+    }
+    const { forceColor = true, timeout = 10, onNestedInvoke, depth = 0, callStack = [] } = options;
+    // Apply the GROQ rule before preparing a build so a filtered-out event skips
+    // the (potentially expensive) transpile entirely.
+    let filteredData = payload?.payload?.data || {};
+    if (resource.type === 'sanity.function.document' ||
+        resource.type === 'sanity.function.media-library.asset') {
+        if (!isGroqContextOptions(context)) {
+            throw new Error('GROQ-based functions require a context with clientOptions');
+        }
+        const { projectId, dataset } = context.clientOptions;
+        if ('before' in payload) {
+            filteredData = await applyGroqRule(resource, payload, projectId, dataset);
+            if (typeof filteredData === 'undefined') {
+                return {
+                    logs: `⚠️ Filter "${resource.event?.filter}" returned an empty result. Skipping invoke.`,
+                    error: undefined,
+                    json: undefined,
+                };
+            }
+        }
+    }
+    // Acquire a shared, reference-counted build. Concurrent invokes of the same
+    // function reuse one transpile + temp package.json instead of racing on the
+    // per-function build paths; the build is torn down once every invoke releases.
+    const build = acquireFunctionBuild(resource);
+    let functionPath;
+    let bundleTimings;
+    try {
+        const prepared = await build.ready;
+        functionPath = prepared.functionPath;
+        bundleTimings = prepared.bundleTimings;
+    }
+    catch (err) {
+        await build.release();
+        throw err;
+    }
+    return new Promise((resolve, reject) => {
+        let child;
+        let timer;
+        let executionStart;
+        // The protocol is no longer one-shot: the child stays alive across nested
+        // `context.invoke` calls, so several handlers (result/exit/error/timeout)
+        // can race to settle this Promise. `settled` ensures exactly one wins and
+        // that shutdown/cleanup only runs once.
+        let settled = false;
+        // Timeout budget is paused while nested invokes run so a function's own
+        // time limit isn't consumed by the functions it calls.
+        let pendingNested = 0;
+        let timerStart = 0;
+        let remaining = timeout * 1000;
+        const nestedTimings = {};
+        // Output the child writes directly to its stdio pipes (anything that escapes
+        // the in-process console capture, e.g. a native crash). Hoisted to the
+        // Promise scope so both the timeout and exit handlers can surface it.
+        let stdout = '';
+        let stderr = '';
+        function startTimer() {
+            timerStart = performance.now();
+            timer = setTimeout(() => {
+                if (settled)
+                    return;
+                settled = true;
+                const executionTimeMs = performance.now() - executionStart;
+                shutdown();
+                // Resolve with error to retain all logs
+                resolve({
+                    json: undefined,
+                    logs: sanitizeLogs(stdout),
+                    error: {
+                        name: 'Error',
+                        message: `Timeout: Function exceeded the ${timeout}-second time limit.`,
+                        stack: '',
+                    },
+                    timings: {
+                        ...bundleTimings,
+                        ...nestedTimings,
+                        execute: executionTimeMs,
+                    },
+                });
+            }, Math.max(0, remaining));
+        }
+        function pauseTimer() {
+            if (pendingNested === 0) {
+                clearTimeout(timer);
+                remaining -= performance.now() - timerStart;
+            }
+            pendingNested += 1;
+        }
+        function resumeTimer() {
+            pendingNested -= 1;
+            if (pendingNested === 0 && !settled) {
+                startTimer();
+            }
+        }
+        // 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;
+            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);
+                nestedTimings[`invoke:${name}`] =
+                    (nestedTimings[`invoke:${name}`] ?? 0) + (performance.now() - nestedStart);
+                // Fire-and-forget contract: in production `context.invoke` returns once the
+                // message is enqueued (Lambda InvocationType:'Event', SNS/SQS), so a
+                // downstream handler error never reaches the caller. Mirror that here —
+                // the target ran (it was "dispatched"), so resolve the caller regardless
+                // 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 },
+                    };
+                    child.send(JSON.stringify(response));
+                }
+            }
+            catch (error) {
+                // The invoke could not be dispatched at all (unknown function, recursion
+                // guard, unsupported context). That is an enqueue-time failure, which in
+                // production rejects synchronously, so propagate it to the caller.
+                if (child && !child.killed) {
+                    const response = {
+                        type: 'invoke-response',
+                        id,
+                        ok: false,
+                        error: {
+                            message: error instanceof Error ? error.message : String(error),
+                            stack: error instanceof Error ? (error.stack ?? '') : '',
+                            name: error instanceof Error ? error.name : 'Error',
+                        },
+                    };
+                    child.send(JSON.stringify(response));
+                }
+            }
+            finally {
+                resumeTimer();
+            }
+        }
+        function start() {
+            executionStart = performance.now();
+            child = spawn('node', ['--enable-source-maps', getChildProcessWrapperPath()], {
+                cwd: cwd(),
+                stdio: ['pipe', 'pipe', 'pipe', 'ipc'], // changed: use 'pipe' so we can capture output
+                env: { ...process.env, ...resource.env, FORCE_COLOR: forceColor ? '1' : '0' },
+            });
+            child.stdout?.on('data', (data) => {
+                stdout += data.toString();
+            });
+            child.stderr?.on('data', (data) => {
+                stderr += data.toString();
+            });
+            child.on('message', (data) => {
+                let msg;
+                try {
+                    msg = JSON.parse(data.toString());
+                }
+                catch {
+                    return;
+                }
+                // Nested invoke request — handle without tearing down the child.
+                if (msg?.type === 'invoke-request') {
+                    handleNestedInvoke({ id: msg.id, name: msg.name, payload: msg.payload });
+                    return;
+                }
+                // Terminal result message.
+                if (settled)
+                    return;
+                settled = true;
+                const executionTimeMs = performance.now() - executionStart;
+                shutdown();
+                resolve({
+                    json: msg.json,
+                    logs: sanitizeLogs(msg.logs ?? ''),
+                    error: msg.error,
+                    timings: {
+                        ...bundleTimings,
+                        ...nestedTimings,
+                        execute: executionTimeMs,
+                    },
+                });
+            });
+            child.on('error', (error) => {
+                if (settled)
+                    return;
+                settled = true;
+                shutdown();
+                reject(new Error(`encountered error ${error.message}`));
+            });
+            // Resolve on 'close' to drain the pipes
+            child.on('close', (code) => {
+                if (settled)
+                    return;
+                settled = true;
+                const executionTimeMs = performance.now() - executionStart;
+                shutdown();
+                if (code !== 0) {
+                    // use captured stderr if available
+                    const message = stderr.trim().length > 0
+                        ? `Process failed with code ${code}\n${stderr}`
+                        : `exited with code ${code}`;
+                    // Resolve with error to retain all logs
+                    resolve({
+                        json: undefined,
+                        logs: sanitizeLogs(stdout),
+                        error: { name: 'Error', message, stack: '' },
+                        timings: {
+                            ...bundleTimings,
+                            ...nestedTimings,
+                            execute: executionTimeMs,
+                        },
+                    });
+                }
+                else {
+                    resolve({
+                        json: undefined,
+                        logs: sanitizeLogs(stdout),
+                        error: undefined,
+                        timings: {
+                            ...bundleTimings,
+                            ...nestedTimings,
+                            execute: executionTimeMs,
+                        },
+                    });
+                }
+            });
+            startTimer();
+            const payload = {
+                data: { ...filteredData },
+                context: {
+                    ...context,
+                    local: true,
+                    resources: groupBlueprintResources(context.resources ?? []),
+                    ...(isGroqContextOptions(context) && {
+                        clientOptions: {
+                            ...context.clientOptions,
+                            apiHost: config.apiUrl,
+                        },
+                    }),
+                },
+            };
+            const startMessage = { type: 'start', srcPath: functionPath, payload };
+            child.send(JSON.stringify(startMessage));
+        }
+        function shutdown() {
+            clearTimeout(timer);
+            if (child && !child.killed) {
+                child.kill();
+            }
+            // Release our reference to the shared build; its temp package.json and
+            // bundle are cleaned up once the last concurrent invoke releases.
+            build.release().catch((err) => console.warn('Build cleanup failed:', err));
+        }
+        start();
+    });
+}

package/dist/utils/functions/invoke/nested.d.ts

@@ -0,0 +1,25 @@
+import type { FunctionResource, InvocationResponse, InvokeContextOptions, InvokeExecutionOptions, InvokePayloadOptions } from '../../types.js';
+/**
+ * Upper bound on nested `context.invoke` recursion, a backstop against invoke loops.
+ * Set to 16 to match Functions service lineage limit.
+ */
+export declare const MAX_INVOKE_DEPTH = 16;
+/**
+ * Guard a nested `context.invoke(name)` against runaway recursion and cycles.
+ * `depth` is the depth at which the target would run and `callStack` is the chain
+ * of function names already running (innermost last). Throws a descriptive error
+ * when the call must be rejected; returns normally when it is safe to proceed.
+ *
+ * This is an enqueue-time check: it runs before the target is dispatched, so the
+ * throw propagates to the caller's `context.invoke` (unlike a downstream handler
+ * error, which is fire-and-forget). See `handleNestedInvoke` in local.ts.
+ */
+export declare function assertNestedInvokeAllowed(name: string, depth: number, callStack: string[]): void;
+/**
+ * Execute a single already-resolved function in its own child process as one
+ * step of an invoke chain: enforce the depth/cycle guard, run it with the call
+ * stack extended by this function, and normalize timings.
+ */
+export declare function runFunction(resource: FunctionResource, payload: InvokePayloadOptions, context: InvokeContextOptions, options: InvokeExecutionOptions): Promise<InvocationResponse & {
+    timings: Record<string, number>;
+}>;

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

@@ -0,0 +1,41 @@
+import invoke from './local.js';
+/**
+ * Upper bound on nested `context.invoke` recursion, a backstop against invoke loops.
+ * Set to 16 to match Functions service lineage limit.
+ */
+export const MAX_INVOKE_DEPTH = 16;
+/**
+ * Guard a nested `context.invoke(name)` against runaway recursion and cycles.
+ * `depth` is the depth at which the target would run and `callStack` is the chain
+ * of function names already running (innermost last). Throws a descriptive error
+ * when the call must be rejected; returns normally when it is safe to proceed.
+ *
+ * This is an enqueue-time check: it runs before the target is dispatched, so the
+ * throw propagates to the caller's `context.invoke` (unlike a downstream handler
+ * error, which is fire-and-forget). See `handleNestedInvoke` in local.ts.
+ */
+export function assertNestedInvokeAllowed(name, depth, callStack) {
+    if (depth > MAX_INVOKE_DEPTH) {
+        throw new Error(`Maximum invoke depth (${MAX_INVOKE_DEPTH}) exceeded`);
+    }
+    if (callStack.includes(name)) {
+        throw new Error(`Invoke cycle detected: ${[...callStack, name].join(' → ')}`);
+    }
+}
+/**
+ * Execute a single already-resolved function in its own child process as one
+ * step of an invoke chain: enforce the depth/cycle guard, run it with the call
+ * stack extended by this function, and normalize timings.
+ */
+export async function runFunction(resource, payload, context, options) {
+    const { forceColor, timeout, depth = 0, callStack = [], onNestedInvoke } = options;
+    assertNestedInvokeAllowed(resource.name, depth, callStack);
+    const response = await invoke(resource, payload, context, {
+        forceColor,
+        timeout: timeout ?? resource.timeout,
+        onNestedInvoke,
+        depth,
+        callStack: [...callStack, resource.name],
+    });
+    return { ...response, timings: response.timings ?? {} };
+}

package/dist/utils/functions/invoke/prepare.d.ts

@@ -0,0 +1,20 @@
+import type { FunctionResource } from '../../types.js';
+/** Everything a child process needs to run a prepared function. */
+export interface PreparedFunction {
+    /** Absolute path to the entry file the child should import. */
+    functionPath: string;
+    /** Timings recorded while bundling, merged into the invocation result. */
+    bundleTimings?: Record<string, number>;
+}
+/** A reference-counted handle to a shared build. Call `release()` once per acquire. */
+export interface FunctionBuild {
+    ready: Promise<PreparedFunction>;
+    release: () => Promise<void>;
+}
+/**
+ * Acquire a shared, reference-counted build for `resource`. The first caller runs
+ * the transpile + temp package.json setup; concurrent callers reuse it. Every
+ * caller MUST call `release()` exactly once when its child has exited, so the
+ * shared artifacts are torn down only after the last in-flight invoke finishes.
+ */
+export declare function acquireFunctionBuild(resource: FunctionResource): FunctionBuild;

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

@@ -0,0 +1,90 @@
+import { findFunctionEntryPoint } from '../find-entry-point.js';
+import { cleanupTempPackageJson, createTempPackageJson, doesPackageJsonExists, } from '../package-json.js';
+import { resolveResourceDependencies } from '../resolve-dependencies.js';
+import { shouldAutoResolveDependencies } from '../should-auto-resolve-deps.js';
+import { shouldTranspileFunction } from '../should-transpile.js';
+import { transpileFunction } from '../transpile/function.js';
+/**
+ * In-progress builds keyed by function identity. Concurrent invokes of the same
+ * function (e.g. `Promise.all([context.invoke('f'), context.invoke('f')])`) share
+ * a single build and a single temp package.json, so they don't race on the
+ * deterministic per-function paths (`.build/function-<name>`, the temp
+ * package.json). The entry is removed once the last concurrent invoke releases
+ * it, so a later, non-overlapping invoke rebuilds and picks up source changes.
+ */
+const builds = new Map();
+function buildKey(resource) {
+    return `${resource.name}:${resource.src}`;
+}
+/**
+ * Acquire a shared, reference-counted build for `resource`. The first caller runs
+ * the transpile + temp package.json setup; concurrent callers reuse it. Every
+ * caller MUST call `release()` exactly once when its child has exited, so the
+ * shared artifacts are torn down only after the last in-flight invoke finishes.
+ */
+export function acquireFunctionBuild(resource) {
+    const key = buildKey(resource);
+    let entry = builds.get(key);
+    if (!entry) {
+        let cleanupBundle = async () => { };
+        let functionPath = '';
+        let createdTempPackageJson = false;
+        // If no package.json exists we create a temporary one to avoid the
+        // "module type" warning from node.
+        const existingPackageJson = doesPackageJsonExists(resource);
+        const ready = (async () => {
+            if (!resource.src) {
+                throw new Error(`Function resource "${resource.name}" is missing the 'src' property.`);
+            }
+            let bundleTimings;
+            const shouldTranspile = await shouldTranspileFunction(resource);
+            if (shouldTranspile) {
+                const transpileResult = await transpileFunction(resource);
+                functionPath = await findFunctionEntryPoint(transpileResult.outputDir);
+                bundleTimings = transpileResult.timings;
+                cleanupBundle = transpileResult.cleanup;
+            }
+            else {
+                functionPath = await findFunctionEntryPoint(resource.src, resource.displayName ?? resource.name);
+            }
+            const shouldResolveDependencies = await shouldAutoResolveDependencies(resource);
+            if (shouldResolveDependencies && existingPackageJson) {
+                await resolveResourceDependencies(resource, { transpiled: shouldTranspile });
+            }
+            if (!existingPackageJson) {
+                createTempPackageJson(functionPath);
+                createdTempPackageJson = true;
+            }
+            return { functionPath, bundleTimings };
+        })();
+        entry = {
+            refs: 0,
+            ready,
+            teardown: async () => {
+                // rmSync is synchronous, so the temp package.json is gone before this
+                // function yields — a later invoke of the same function can't observe a
+                // half-removed state.
+                if (createdTempPackageJson) {
+                    cleanupTempPackageJson(functionPath);
+                }
+                await cleanupBundle().catch((err) => console.warn('Bundle cleanup failed:', err));
+            },
+        };
+        builds.set(key, entry);
+    }
+    const activeEntry = entry;
+    activeEntry.refs += 1;
+    let released = false;
+    const release = async () => {
+        if (released)
+            return;
+        released = true;
+        activeEntry.refs -= 1;
+        if (activeEntry.refs === 0) {
+            if (builds.get(key) === activeEntry)
+                builds.delete(key);
+            await activeEntry.teardown();
+        }
+    };
+    return { ready: activeEntry.ready, release };
+}

package/dist/utils/interactive.d.ts

@@ -0,0 +1 @@
+export declare const isInteractive: boolean;

package/dist/utils/interactive.js

@@ -0,0 +1,4 @@
+function testIsInteractive() {
+    return Boolean(process.stdin.isTTY && process.stdout.isTTY);
+}
+export const isInteractive = testIsInteractive();

package/dist/utils/isTrueish.d.ts

@@ -0,0 +1,6 @@
+/**
+ * Quick check for 'true' or '1' from env
+ * @param val
+ */
+declare const isTrueish: (val?: string) => boolean;
+export default isTrueish;

package/dist/utils/isTrueish.js

@@ -0,0 +1,9 @@
+/**
+ * Quick check for 'true' or '1' from env
+ * @param val
+ */
+const isTrueish = (val) => {
+    const v = (val ?? '').toLowerCase();
+    return v === 'true' || parseInt(v, 10) > 0;
+};
+export default isTrueish;