lambda-live-debugger 1.12.7 → 1.12.9

package/node_modules/@inquirer/core/dist/lib/create-prompt.js

@@ -1,15 +1,28 @@
 import * as readline from 'node:readline';
 import { AsyncResource } from 'node:async_hooks';
+import { withResolver } from '@inquirer/type';
 import MuteStream from 'mute-stream';
 import { onExit as onSignalExit } from 'signal-exit';
-import ScreenManager from "./screen-manager.js";
-import { PromisePolyfill } from "./promise-polyfill.js";
-import { withHooks, effectScheduler } from "./hook-engine.js";
-import { AbortPromptError, CancelPromptError, ExitPromptError } from "./errors.js";
+import ScreenManager from './screen-manager.js';
+import { withHooks, effectScheduler } from './hook-engine.js';
+import { AbortPromptError, CancelPromptError, ExitPromptError } from './errors.js';
 import path from 'node:path';
 // Capture the real setImmediate at module load time so it works even when test
 // frameworks mock timers with vi.useFakeTimers() or similar.
 const nativeSetImmediate = globalThis.setImmediate;
+const nativeClearImmediate = globalThis.clearImmediate;
+/**
+ * Register an event listener and return its disposer, so registrations collapse
+ * into a single statement: `cleanups.add(listenTo(rl, 'close', handler))`.
+ */
+function listenTo(target, event, listener) {
+    if ('on' in target) {
+        target.on(event, listener);
+        return () => target.removeListener(event, listener);
+    }
+    target.addEventListener(event, listener);
+    return () => target.removeEventListener(event, listener);
+}
 function getCallSites() {
     // oxlint-disable-next-line typescript/unbound-method
     const savedPrepareStackTrace = Error.prepareStackTrace;
@@ -40,54 +53,77 @@ export function createPrompt(view) {
         // Add mute capabilities to the output
         const output = new MuteStream();
         output.pipe(context.output ?? process.stdout);
-        // oxlint-disable-next-line typescript/no-unsafe-type-assertion
+        /* oxlint-disable typescript/no-unsafe-type-assertion */
         const rl = readline.createInterface({
             terminal: true,
             input,
             output,
         });
+        /* oxlint-enable typescript/no-unsafe-type-assertion */
         // Mute the output after readline has initialized so readline can perform
         // any terminal setup writes (e.g. Windows Console API initialization)
         // before suppressing output. ScreenManager will unmute/mute around each
         // render call as needed.
         output.mute();
         const screen = new ScreenManager(rl);
-        const { promise, resolve, reject } = PromisePolyfill.withResolver();
-        const cancel = () => reject(new CancelPromptError());
-        if (signal) {
-            const abort = () => reject(new AbortPromptError({ cause: signal.reason }));
-            if (signal.aborted) {
-                abort();
-                return Object.assign(promise, { cancel });
-            }
-            signal.addEventListener('abort', abort);
-            cleanups.add(() => signal.removeEventListener('abort', abort));
-        }
-        cleanups.add(onSignalExit((code, signal) => {
-            reject(new ExitPromptError(`User force closed the prompt with ${code} ${signal}`));
-        }));
-        // SIGINT must be explicitly handled by the prompt so the ExitPromptError can be handled.
-        // Otherwise, the prompt will stop and in some scenarios never resolve.
-        // Ref issue #1741
-        const sigint = () => reject(new ExitPromptError(`User force closed the prompt with SIGINT`));
-        rl.on('SIGINT', sigint);
-        cleanups.add(() => rl.removeListener('SIGINT', sigint));
+        const { promise, resolve, reject } = withResolver();
         return withHooks(rl, (cycle) => {
-            // The close event triggers immediately when the user press ctrl+c. SignalExit on the other hand
-            // triggers after the process is done (which happens after timeouts are done triggering.)
-            // We triggers the hooks cleanup phase on rl `close` so active timeouts can be cleared.
-            const hooksCleanup = AsyncResource.bind(() => effectScheduler.clearAll());
-            rl.on('close', hooksCleanup);
-            cleanups.add(() => rl.removeListener('close', hooksCleanup));
+            // Clear hook effects synchronously before the prompt settles: readline
+            // emits keypresses synchronously within a single data event, so a
+            // microtask-deferred cleanup would let same-tick input keep driving a
+            // settled prompt.
+            const clearEffects = AsyncResource.bind(() => effectScheduler.clearAll());
+            // The promise resolvers and effectScheduler.clearAll() are both idempotent,
+            // so repeated settlement attempts are harmless no-ops. If a hook cleanup
+            // throws, the cleanup error supersedes the settlement: the answer (or
+            // settlement error, e.g. AbortPromptError) is dropped in favor of
+            // rejecting with the cleanup error.
+            const settlePrompt = (settle) => {
+                try {
+                    clearEffects();
+                    settle();
+                }
+                catch (error) {
+                    reject(error);
+                }
+            };
+            const resolvePrompt = (value) => settlePrompt(() => resolve(value));
+            const rejectPrompt = (error) => settlePrompt(() => reject(error));
+            const promptPromise = Object.assign(promise
+                .finally(() => {
+                cleanups.forEach((cleanup) => cleanup());
+                screen.done({ clearContent: Boolean(context.clearPromptOnDone) });
+                output.end();
+            })
+                .then(() => promise), { cancel: () => rejectPrompt(new CancelPromptError()) });
+            if (signal) {
+                const abort = () => rejectPrompt(new AbortPromptError({ cause: signal.reason }));
+                if (signal.aborted) {
+                    abort();
+                    return promptPromise;
+                }
+                cleanups.add(listenTo(signal, 'abort', abort));
+            }
+            cleanups.add(onSignalExit((code, signal) => {
+                rejectPrompt(new ExitPromptError(`User force closed the prompt with ${code} ${signal}`));
+            }));
+            // SIGINT must be explicitly handled by the prompt so the ExitPromptError can be handled.
+            // Otherwise, the prompt will stop and in some scenarios never resolve.
+            // Ref issue #1741
+            cleanups.add(listenTo(rl, 'SIGINT', () => rejectPrompt(new ExitPromptError(`User force closed the prompt with SIGINT`))));
+            // Fallback for readline closing without the prompt settling (e.g. stdin
+            // EOF), so active effect timeouts still get cleared. Every settlement
+            // path already clears effects through settlePrompt; this event triggers
+            // immediately when the user presses ctrl+c, while signal-exit only
+            // triggers after the process is done (after timeouts finish triggering).
+            cleanups.add(listenTo(rl, 'close', clearEffects));
             const startCycle = () => {
                 // Re-renders only happen when the state change; but the readline cursor could
                 // change position and that also requires a re-render (and a manual one because
                 // we mute the streams). We set the listener after the initial workLoop to avoid
                 // a double render if render triggered by a state change sets the cursor to the
                 // right position.
-                const checkCursorPos = () => screen.checkCursorPos();
-                rl.input.on('keypress', checkCursorPos);
-                cleanups.add(() => rl.input.removeListener('keypress', checkCursorPos));
+                cleanups.add(listenTo(rl.input, 'keypress', () => screen.checkCursorPos()));
                 let pendingDone = null;
                 cycle(() => {
                     let effectsSettled = false;
@@ -97,7 +133,7 @@ export function createPrompt(view) {
                                 // After the cycle completes (async validation path), the "done"
                                 // render already flushed via setStatus → handleChange, so resolve
                                 // immediately.
-                                resolve(value);
+                                resolvePrompt(value);
                             }
                             else {
                                 pendingDone = { value };
@@ -117,13 +153,13 @@ export function createPrompt(view) {
                         effectScheduler.run();
                     }
                     catch (error) {
-                        reject(error);
+                        rejectPrompt(error);
                     }
                     effectsSettled = true;
                     if (pendingDone !== null) {
                         const { value } = pendingDone;
                         pendingDone = null;
-                        resolve(value);
+                        resolvePrompt(value);
                     }
                 });
             };
@@ -133,32 +169,25 @@ export function createPrompt(view) {
             // poll) lets that stale data flow through readline harmlessly—no keypress
             // handlers are registered yet and the output is muted, so the stale
             // keystrokes are silently discarded.
+            // This only applies to TTY inputs, where early data is stale keystrokes
+            // the user typed before the prompt started. Piped input (stdin from a
+            // script or test harness) is intentional: deferring there risks dropping
+            // the answer itself, since data already waiting on the pipe flows
+            // through readline during the deferral tick and is then discarded,
+            // leaving the prompt waiting forever (seen as intermittent 30s timeouts
+            // in the Deno integration suite).
             // Old-style streams (like MuteStream) have no such buffering, so the
             // render cycle starts immediately.
             //
             // @see https://github.com/SBoudrias/Inquirer.js/issues/1303
-            if ('readableFlowing' in input) {
-                nativeSetImmediate(startCycle);
+            if ('readableFlowing' in input && input.isTTY) {
+                const immediate = nativeSetImmediate(startCycle);
+                cleanups.add(() => nativeClearImmediate(immediate));
             }
             else {
                 startCycle();
             }
-            return Object.assign(promise
-                .then((answer) => {
-                effectScheduler.clearAll();
-                return answer;
-            }, (error) => {
-                effectScheduler.clearAll();
-                throw error;
-            })
-                // Wait for the promise to settle, then cleanup.
-                .finally(() => {
-                cleanups.forEach((cleanup) => cleanup());
-                screen.done({ clearContent: Boolean(context.clearPromptOnDone) });
-                output.end();
-            })
-                // Once cleanup is done, let the expose promise resolve/reject to the internal one.
-                .then(() => promise), { cancel });
+            return promptPromise;
         });
     };
     return prompt;

package/node_modules/@inquirer/core/dist/lib/hook-engine.d.ts

@@ -2,17 +2,11 @@ import type { InquirerReadline } from '@inquirer/type';
 export declare function withHooks<T>(rl: InquirerReadline, cb: (cycle: (render: () => void) => void) => T): T;
 export declare function readline(): InquirerReadline;
 export declare function withUpdates<Args extends unknown[], R>(fn: (...args: Args) => R): (...args: Args) => R;
-type SetPointer<Value> = {
+type Pointer<Value> = {
     get(): Value;
     set(value: Value): void;
-    initialized: true;
+    initialized: boolean;
 };
-type UnsetPointer<Value> = {
-    get(): void;
-    set(value: Value): void;
-    initialized: false;
-};
-type Pointer<Value> = SetPointer<Value> | UnsetPointer<Value>;
 export declare function withPointer<Value, ReturnValue>(cb: (pointer: Pointer<Value>) => ReturnValue): ReturnValue;
 export declare function handleChange(): void;
 export declare const effectScheduler: {

package/node_modules/@inquirer/core/dist/lib/hook-engine.js

@@ -1,6 +1,6 @@
 /* eslint @typescript-eslint/no-explicit-any: ["off"] */
 import { AsyncLocalStorage, AsyncResource } from 'node:async_hooks';
-import { HookError, ValidationError } from "./errors.js";
+import { HookError, ValidationError } from './errors.js';
 const hookStorage = new AsyncLocalStorage();
 function createStore(rl) {
     const store = {
@@ -16,16 +16,14 @@ function createStore(rl) {
 // Run callback in with the hook engine setup.
 export function withHooks(rl, cb) {
     const store = createStore(rl);
-    return hookStorage.run(store, () => {
-        function cycle(render) {
-            store.handleChange = () => {
-                store.index = 0;
-                render();
-            };
-            store.handleChange();
-        }
-        return cb(cycle);
-    });
+    function cycle(render) {
+        store.handleChange = () => {
+            store.index = 0;
+            render();
+        };
+        store.handleChange();
+    }
+    return hookStorage.run(store, () => cb(cycle));
 }
 // Safe getStore utility that'll return the store or throw if undefined.
 function getStore() {

package/node_modules/@inquirer/core/dist/lib/make-theme.js

@@ -1,4 +1,4 @@
-import { getDefaultTheme } from "./theme.js";
+import { getDefaultTheme } from './theme.js';
 function isPlainObject(value) {
     if (typeof value !== 'object' || value === null)
         return false;
@@ -23,10 +23,11 @@ function deepMerge(...objects) {
     return output;
 }
 export function makeTheme(...themes) {
-    // oxlint-disable-next-line typescript/no-unsafe-type-assertion
+    /* oxlint-disable typescript/no-unsafe-type-assertion */
     const themesToMerge = [
         getDefaultTheme(),
         ...themes.filter((theme) => theme != null),
     ];
     return deepMerge(...themesToMerge);
+    /* oxlint-enable typescript/no-unsafe-type-assertion */
 }

package/node_modules/@inquirer/core/dist/lib/pagination/use-pagination.d.ts

@@ -1,14 +1,13 @@
-import type { Prettify } from '@inquirer/type';
 export declare function usePagination<T>({ items, active, renderItem, pageSize, loop, }: {
     items: ReadonlyArray<T>;
     /** The index of the active item. */
     active: number;
     /** Renders an item as part of a page. */
-    renderItem: (layout: Prettify<{
+    renderItem: (layout: {
         item: T;
         index: number;
         isActive: boolean;
-    }>) => string;
+    }) => string;
     /** The size of the page. */
     pageSize: number;
     /** Allows creating an infinitely looping list. `true` if unspecified. */

package/node_modules/@inquirer/core/dist/lib/pagination/use-pagination.js

@@ -1,5 +1,5 @@
-import { useRef } from "../use-ref.js";
-import { readlineWidth, breakLines } from "../utils.js";
+import { useRef } from '../use-ref.js';
+import { readlineWidth, breakLines } from '../utils.js';
 function usePointerPosition({ active, renderedItems, pageSize, loop, }) {
     const state = useRef({
         lastPointer: active,

package/node_modules/@inquirer/core/dist/lib/screen-manager.js

@@ -1,5 +1,5 @@
 import { stripVTControlCharacters } from 'node:util';
-import { breakLines, readlineWidth } from "./utils.js";
+import { breakLines, readlineWidth } from './utils.js';
 import { cursorDown, cursorLeft, cursorUp, cursorTo, cursorShow, eraseLines, } from '@inquirer/ansi';
 const height = (content) => content.split('\n').length;
 const lastLine = (content) => content.split('\n').pop() ?? '';

package/node_modules/@inquirer/core/dist/lib/theme.d.ts

@@ -160,7 +160,7 @@ type DefaultTheme = {
         key: (text: string) => string;
     };
 };
-export type Theme<Extension extends object = object> = Prettify<Extension & DefaultTheme>;
+export type Theme<Extension extends object = object> = Extension & DefaultTheme;
 export declare const defaultTheme: DefaultTheme;
 export declare function getDefaultTheme(): DefaultTheme;
 export {};

package/node_modules/@inquirer/core/dist/lib/theme.js

@@ -1,6 +1,6 @@
 import { styleText } from 'node:util';
 import figures from '@inquirer/figures';
-import { getDefaultKeybindings } from "./key.js";
+import { getDefaultKeybindings } from './key.js';
 export const defaultTheme = {
     prefix: {
         idle: styleText('blue', '?'),

package/node_modules/@inquirer/core/dist/lib/use-effect.js

@@ -1,4 +1,4 @@
-import { withPointer, effectScheduler } from "./hook-engine.js";
+import { withPointer, effectScheduler } from './hook-engine.js';
 export function useEffect(cb, depArray) {
     withPointer((pointer) => {
         const oldDeps = pointer.get();

package/node_modules/@inquirer/core/dist/lib/use-keypress.js

@@ -1,6 +1,6 @@
-import { useRef } from "./use-ref.js";
-import { useEffect } from "./use-effect.js";
-import { withUpdates } from "./hook-engine.js";
+import { useRef } from './use-ref.js';
+import { useEffect } from './use-effect.js';
+import { withUpdates } from './hook-engine.js';
 export function useKeypress(userHandler) {
     const signal = useRef(userHandler);
     signal.current = userHandler;

package/node_modules/@inquirer/core/dist/lib/use-memo.js

@@ -1,8 +1,8 @@
-import { withPointer } from "./hook-engine.js";
+import { withPointer } from './hook-engine.js';
 export function useMemo(fn, dependencies) {
     return withPointer((pointer) => {
         const prev = pointer.get();
-        if (!prev ||
+        if (!pointer.initialized ||
             prev.dependencies.length !== dependencies.length ||
             prev.dependencies.some((dep, i) => dep !== dependencies[i])) {
             const value = fn();

package/node_modules/@inquirer/core/dist/lib/use-prefix.js

@@ -1,6 +1,6 @@
-import { useState } from "./use-state.js";
-import { useEffect } from "./use-effect.js";
-import { makeTheme } from "./make-theme.js";
+import { useState } from './use-state.js';
+import { useEffect } from './use-effect.js';
+import { makeTheme } from './make-theme.js';
 export function usePrefix({ status = 'idle', theme, }) {
     const [showLoader, setShowLoader] = useState(false);
     const [tick, setTick] = useState(0);

package/node_modules/@inquirer/core/dist/lib/use-ref.js

@@ -1,4 +1,4 @@
-import { useState } from "./use-state.js";
+import { useState } from './use-state.js';
 export function useRef(val) {
     return useState({ current: val })[0];
 }

package/node_modules/@inquirer/core/dist/lib/use-state.d.ts

@@ -1,4 +1,7 @@
 type NotFunction<T> = T extends (...args: never) => unknown ? never : T;
-export declare function useState<Value>(defaultValue: NotFunction<Value> | (() => Value)): [Value, (newValue: Value) => void];
-export declare function useState<Value>(defaultValue?: NotFunction<Value> | (() => Value)): [Value | undefined, (newValue?: Value) => void];
+type Reducer<Value> = (currentValue: Value) => Value;
+type SetState<Value> = (newValue: NotFunction<Value> | Reducer<Value>) => void;
+type OptionalSetState<Value> = (newValue?: NotFunction<Value> | Reducer<Value>) => void;
+export declare function useState<Value>(defaultValue: NotFunction<Value> | (() => Value)): [Value, SetState<Value>];
+export declare function useState<Value>(defaultValue?: NotFunction<Value> | (() => Value)): [Value | undefined, OptionalSetState<Value | undefined>];
 export {};

package/node_modules/@inquirer/core/dist/lib/use-state.js

@@ -1,14 +1,19 @@
 import { AsyncResource } from 'node:async_hooks';
-import { withPointer, handleChange } from "./hook-engine.js";
+import { withPointer, handleChange } from './hook-engine.js';
 function isFactory(value) {
     return typeof value === 'function';
 }
+function isReducer(value) {
+    return typeof value === 'function';
+}
 export function useState(defaultValue) {
     return withPointer((pointer) => {
         const setState = AsyncResource.bind(function setState(newValue) {
+            const currentValue = pointer.get();
+            const nextValue = isReducer(newValue) ? newValue(currentValue) : newValue;
             // Noop if the value is still the same.
-            if (pointer.get() !== newValue) {
-                pointer.set(newValue);
+            if (!Object.is(currentValue, nextValue)) {
+                pointer.set(nextValue);
                 // Trigger re-render
                 handleChange();
             }

package/node_modules/@inquirer/core/dist/lib/utils.js

@@ -1,6 +1,6 @@
 import cliWidth from 'cli-width';
 import { wrapAnsi } from 'fast-wrap-ansi';
-import { readline } from "./hook-engine.js";
+import { readline } from './hook-engine.js';
 /**
  * Force line returns at specific width. This function is ANSI code friendly and it'll
  * ignore invisible codes during width calculation.

package/node_modules/@inquirer/core/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@inquirer/core",
-  "version": "11.2.1",
+  "version": "12.0.6",
   "description": "Core Inquirer prompt API",
   "keywords": [
     "answer",
@@ -41,7 +41,7 @@
     "yo",
     "zsh"
   ],
-  "homepage": "https://github.com/SBoudrias/Inquirer.js/blob/main/packages/core/README.md",
+  "homepage": "https://github.com/SBoudrias/Inquirer.js/blob/HEAD/packages/core/README.md",
   "license": "MIT",
   "author": "Simon Boudrias <admin@simonboudrias.com>",
   "repository": {
@@ -67,18 +67,19 @@
     "tsc": "tsc"
   },
   "dependencies": {
-    "@inquirer/ansi": "^2.0.7",
-    "@inquirer/figures": "^2.0.7",
-    "@inquirer/type": "^4.0.7",
+    "@inquirer/ansi": "^2.0.10",
+    "@inquirer/figures": "^2.0.10",
+    "@inquirer/type": "4.2.1",
     "cli-width": "^4.1.0",
     "fast-wrap-ansi": "^0.2.0",
     "mute-stream": "^3.0.0",
     "signal-exit": "^4.1.0"
   },
   "devDependencies": {
+    "@repo/tsconfig": "0.0.0",
     "@types/mute-stream": "^0.0.4",
-    "@types/node": "^25.5.2",
-    "typescript": "^6.0.2"
+    "@types/node": "^26.1.1",
+    "typescript": "^7.0.2"
   },
   "peerDependencies": {
     "@types/node": ">=18"
@@ -93,5 +94,5 @@
   },
   "main": "./dist/index.js",
   "types": "./dist/index.d.ts",
-  "gitHead": "b43359d803733b1a7c4638addcc270987fb894c3"
+  "gitHead": "672b77f0486388d7f5c35487d89a5ff63f4c54dd"
 }

package/node_modules/@inquirer/editor/README.md

@@ -8,46 +8,116 @@ The editor launched is the one [defined by the user's `EDITOR` environment varia
 
 <table>
 <tr>
-  <th>npm</th>
   <th>yarn</th>
+  <th>pnpm</th>
 </tr>
 <tr>
 <td>
 
 ```sh
-npm install @inquirer/prompts
+yarn add @inquirer/prompts
 ```
 
 </td>
 <td>
 
 ```sh
-yarn add @inquirer/prompts
+pnpm add @inquirer/prompts
 ```
 
 </td>
 </tr>
 <tr>
-<td colSpan="2" align="center">Or</td>
+  <th>bun</th>
+  <th>deno</th>
 </tr>
 <tr>
 <td>
 
 ```sh
-npm install @inquirer/editor
+bun add @inquirer/prompts
 ```
 
 </td>
 <td>
 
+```sh
+deno add npm:@inquirer/prompts
+```
+
+</td>
+</tr>
+<tr>
+<th colSpan="2">npm</th>
+</tr>
+<tr>
+<td colSpan="2">
+
+```sh
+npm install @inquirer/prompts
+```
+
+</td>
+</tr>
+<tr>
+<td colSpan="2" align="center">Or</td>
+</tr>
+<tr>
+  <th>yarn</th>
+  <th>pnpm</th>
+</tr>
+<tr>
+<td>
+
 ```sh
 yarn add @inquirer/editor
 ```
 
+</td>
+<td>
+
+```sh
+pnpm add @inquirer/editor
+```
+
+</td>
+</tr>
+<tr>
+  <th>bun</th>
+  <th>deno</th>
+</tr>
+<tr>
+<td>
+
+```sh
+bun add @inquirer/editor
+```
+
+</td>
+<td>
+
+```sh
+deno add npm:@inquirer/editor
+```
+
+</td>
+</tr>
+<tr>
+<th colSpan="2">npm</th>
+</tr>
+<tr>
+<td colSpan="2">
+
+```sh
+npm install @inquirer/editor
+```
+
 </td>
 </tr>
 </table>
 
+On Deno, prompts detect the terminal's unicode and color support from the environment, so run your script with `--allow-env`.
+
 # Usage
 
 ```js

package/node_modules/@inquirer/editor/dist/index.d.ts

@@ -10,12 +10,20 @@ type EditorTheme = {
 };
 type EditorConfig = {
     message: string;
-    default?: string;
+    default?: string | undefined;
     postfix?: string;
     waitForUserInput?: boolean;
     validate?: (value: string) => boolean | string | Promise<string | boolean>;
     file?: FileOptions;
     theme?: PartialDeep<Theme<EditorTheme>>;
 };
-declare const _default: import("@inquirer/type").Prompt<string, EditorConfig>;
+declare const _default: import("@inquirer/type").Prompt<string, {
+    message: string;
+    default?: string | undefined;
+    postfix?: string;
+    waitForUserInput?: boolean;
+    validate?: (value: string) => boolean | string | Promise<string | boolean>;
+    file?: FileOptions;
+    theme?: PartialDeep<Theme<EditorTheme>>;
+} & EditorConfig>;
 export default _default;