@socketsecurity/lib 6.0.6 → 6.0.7

package/dist/smol/manifest.js

@@ -18,20 +18,19 @@ const require_node_module = require('../node/module.js');
 *   (`@socketsecurity/lib/eco/manifest/parse`), which already routes
 *   through this when smol is present.
 */
-let _smolManifest;
-let _smolManifestProbed = false;
+let cachedSmolManifest;
+let smolManifestProbed = false;
 /**
 * Returns `node:smol-manifest` when running on the smol Node binary, otherwise
 * `undefined`. Result is cached across calls.
 */
-/*@__NO_SIDE_EFFECTS__*/
 function getSmolManifest() {
-	if (!_smolManifestProbed) {
-		_smolManifestProbed = true;
+	if (!smolManifestProbed) {
+		smolManifestProbed = true;
 		/* c8 ignore start - smol Node binary only. */
-		if (/* @__PURE__ */ require_node_module.isNodeBuiltin("node:smol-manifest")) _smolManifest = require("node:smol-manifest");
+		if (require_node_module.isNodeBuiltin("node:smol-manifest")) cachedSmolManifest = require("node:smol-manifest");
 	}
-	return _smolManifest;
+	return cachedSmolManifest;
 }
 
 //#endregion

package/dist/smol/path.d.ts

@@ -6,7 +6,7 @@
  *   and on socket-btm binaries that haven't shipped the binding yet; callers
  *   fall back to the JS implementation. Result is cached. The binding does not
  *   exist yet (the plan is unbuilt) — this accessor is the seam so that when it
- *   lands, only this file changes and `paths/walk`, `fs/access`, `fs/find-up`
+ *   lands, only this file changes and `paths/walk`, `fs/access`, `fs/find`
  *   light up natively. Today `getSmolPath()` is always `undefined` and the JS
  *   paths run.
  */

package/dist/smol/path.js

@@ -12,26 +12,25 @@ const require_node_module = require('../node/module.js');
 *   and on socket-btm binaries that haven't shipped the binding yet; callers
 *   fall back to the JS implementation. Result is cached. The binding does not
 *   exist yet (the plan is unbuilt) — this accessor is the seam so that when it
-*   lands, only this file changes and `paths/walk`, `fs/access`, `fs/find-up`
+*   lands, only this file changes and `paths/walk`, `fs/access`, `fs/find`
 *   light up natively. Today `getSmolPath()` is always `undefined` and the JS
 *   paths run.
 */
-let _smolPath;
-let _smolPathProbed = false;
+let smolPathCache;
+let smolPathProbed = false;
 /**
 * Returns the `node:smol-path` binding when running on a smol Node binary that
 * ships it; otherwise `undefined`. Cached across calls.
 *
 * @returns The native binding, or `undefined` to signal "use the JS fallback".
 */
-/*@__NO_SIDE_EFFECTS__*/
 function getSmolPath() {
-	if (!_smolPathProbed) {
-		_smolPathProbed = true;
+	if (!smolPathProbed) {
+		smolPathProbed = true;
 		/* c8 ignore start - smol Node binary only. */
-		if (/* @__PURE__ */ require_node_module.isNodeBuiltin("node:smol-path")) _smolPath = require("node:smol-path");
+		if (require_node_module.isNodeBuiltin("node:smol-path")) smolPathCache = require("node:smol-path");
 	}
-	return _smolPath;
+	return smolPathCache;
 }
 
 //#endregion

package/dist/smol/primordial.d.ts

@@ -67,6 +67,10 @@ export interface SmolPrimordialBinding {
     numberParseInt10(s: string): number;
     stringCharCodeAt(s: string, i: number): number;
     stringIsWellFormed(s: string): boolean;
+    IntlCollator: typeof Intl.Collator;
+    IntlListFormat: typeof Intl.ListFormat;
+    IntlPluralRules: typeof Intl.PluralRules;
+    IntlSegmenter: typeof Intl.Segmenter;
 }
 /**
  * Returns `node:smol-primordial` when running on the smol Node binary,

package/dist/smol/primordial.js

@@ -20,20 +20,19 @@ const require_node_module = require('../node/module.js');
 *
 * @see https://v8.dev/blog/v8-release-99 — V8 Fast API Calls overview
 */
-let _smolPrimordial;
-let _smolPrimordialProbed = false;
+let smolPrimordial;
+let smolPrimordialProbed = false;
 /**
 * Returns `node:smol-primordial` when running on the smol Node binary,
 * otherwise `undefined`. Result is cached across calls.
 */
-/*@__NO_SIDE_EFFECTS__*/
 function getSmolPrimordial() {
-	if (!_smolPrimordialProbed) {
-		_smolPrimordialProbed = true;
+	if (!smolPrimordialProbed) {
+		smolPrimordialProbed = true;
 		/* c8 ignore start - smol Node binary only. */
-		if (/* @__PURE__ */ require_node_module.isNodeBuiltin("node:smol-primordial")) _smolPrimordial = require("node:smol-primordial");
+		if (require_node_module.isNodeBuiltin("node:smol-primordial")) smolPrimordial = require("node:smol-primordial");
 	}
-	return _smolPrimordial;
+	return smolPrimordial;
 }
 
 //#endregion

package/dist/smol/purl.d.ts

@@ -7,7 +7,7 @@
  *   calls. Callers fall back to the JS `@socketregistry/packageurl-js` import
  *   on the undefined path.
  *
- * @internal — used by `src/packages/operations.ts` to resolve the
+ * @internal — used by `src/packages/specs.ts` to resolve the
  *   `pkg:npm/<name>` parse on `resolveRegistryPackageName`. Most
  *   callers should keep using `PackageURL` from
  *   `external/@socketregistry/packageurl-js` directly; this loader

package/dist/smol/purl.js

@@ -13,26 +13,25 @@ const require_node_module = require('../node/module.js');
 *   calls. Callers fall back to the JS `@socketregistry/packageurl-js` import
 *   on the undefined path.
 *
-* @internal — used by `src/packages/operations.ts` to resolve the
+* @internal — used by `src/packages/specs.ts` to resolve the
 *   `pkg:npm/<name>` parse on `resolveRegistryPackageName`. Most
 *   callers should keep using `PackageURL` from
 *   `external/@socketregistry/packageurl-js` directly; this loader
 *   only matters where the hot path warrants the native acceleration.
 */
-let _smolPurl;
-let _smolPurlProbed = false;
+let smolPurl;
+let smolPurlProbed = false;
 /**
 * Returns `node:smol-purl` when running on the smol Node binary, otherwise
 * `undefined`. Result is cached across calls.
 */
-/*@__NO_SIDE_EFFECTS__*/
 function getSmolPurl() {
-	if (!_smolPurlProbed) {
-		_smolPurlProbed = true;
+	if (!smolPurlProbed) {
+		smolPurlProbed = true;
 		/* c8 ignore start - smol Node binary only. */
-		if (/* @__PURE__ */ require_node_module.isNodeBuiltin("node:smol-purl")) _smolPurl = require("node:smol-purl");
+		if (require_node_module.isNodeBuiltin("node:smol-purl")) smolPurl = require("node:smol-purl");
 	}
-	return _smolPurl;
+	return smolPurl;
 }
 
 //#endregion

package/dist/smol/versions.js

@@ -16,20 +16,19 @@ const require_node_module = require('../node/module.js');
 *   ops. Most callers should use the standard `versions` exports,
 *   which already route through this when smol is present.
 */
-let _smolVersions;
-let _smolVersionsProbed = false;
+let smolVersions;
+let smolVersionsProbed = false;
 /**
 * Returns `node:smol-versions` when running on the smol Node binary, otherwise
 * `undefined`. Result is cached across calls.
 */
-/*@__NO_SIDE_EFFECTS__*/
 function getSmolVersions() {
-	if (!_smolVersionsProbed) {
-		_smolVersionsProbed = true;
+	if (!smolVersionsProbed) {
+		smolVersionsProbed = true;
 		/* c8 ignore start - smol Node binary only. */
-		if (/* @__PURE__ */ require_node_module.isNodeBuiltin("node:smol-versions")) _smolVersions = require("node:smol-versions");
+		if (require_node_module.isNodeBuiltin("node:smol-versions")) smolVersions = require("node:smol-versions");
 	}
-	return _smolVersions;
+	return smolVersions;
 }
 
 //#endregion

package/dist/smol/vfs.js

@@ -26,8 +26,8 @@ const require_node_module = require('../node/module.js');
 *     binding. Result is cached across calls. Callers fall back to PATH lookup
 *     (or out-of-band downloads in socket-cli's case) when this is missing.
 */
-let _smolVfs;
-let _smolVfsProbed = false;
+let cachedSmolVfs;
+let smolVfsProbed = false;
 /**
 * Returns the pre-mounted SEA `SmolVirtualFileSystem` instance when running on
 * a smol Node binary with an embedded SEA payload; otherwise `undefined`.
@@ -37,14 +37,13 @@ let _smolVfsProbed = false;
 * binding-module loader is collapsed into this function so callers don't deal
 * with two indirection levels.
 */
-/*@__NO_SIDE_EFFECTS__*/
 function getSmolVfs() {
-	if (!_smolVfsProbed) {
-		_smolVfsProbed = true;
+	if (!smolVfsProbed) {
+		smolVfsProbed = true;
 		/* c8 ignore start - smol Node binary only. */
-		if (/* @__PURE__ */ require_node_module.isNodeBuiltin("node:smol-vfs")) _smolVfs = require("node:smol-vfs").getSmolVfs();
+		if (require_node_module.isNodeBuiltin("node:smol-vfs")) cachedSmolVfs = require("node:smol-vfs").getSmolVfs();
 	}
-	return _smolVfs;
+	return cachedSmolVfs;
 }
 
 //#endregion

package/dist/sorts/_internal.js

@@ -3,17 +3,15 @@
 Object.defineProperty(exports, Symbol.toStringTag, { value: 'Module' });
 
 //#region src/sorts/_internal.ts
-let _fastSort;
-let _semver;
-/*@__NO_SIDE_EFFECTS__*/
+let fastSort;
+let semver;
 function getFastSort() {
-	if (_fastSort === void 0) _fastSort = /*@__PURE__*/ require("../external/fast-sort.js");
-	return _fastSort;
+	if (fastSort === void 0) fastSort = /*@__PURE__*/ require("../external/fast-sort.js");
+	return fastSort;
 }
-/*@__NO_SIDE_EFFECTS__*/
 function getSemver() {
-	if (_semver === void 0) _semver = /*@__PURE__*/ require("../external/semver.js");
-	return _semver;
+	if (semver === void 0) semver = /*@__PURE__*/ require("../external/semver.js");
+	return semver;
 }
 
 //#endregion

package/dist/sorts/natural.js

@@ -1,6 +1,7 @@
 "use strict";
 /* Socket Lib - Built with rolldown */
 Object.defineProperty(exports, Symbol.toStringTag, { value: 'Module' });
+const require_primordials_intl = require('../primordials/intl.js');
 const require_sorts__internal = require('./_internal.js');
 
 //#region src/sorts/natural.ts
@@ -11,9 +12,9 @@ const require_sorts__internal = require('./_internal.js');
 *   Intl.Collator()` is 10-14ms in Node — too expensive to call
 *   per-comparison.
 */
-let _localeCompare;
-let _naturalCompare;
-let _naturalSorter;
+let cachedLocaleCompare;
+let cachedNaturalCompare;
+let cachedNaturalSorter;
 /**
 * Compare two strings using locale-aware comparison.
 *
@@ -24,10 +25,9 @@ let _naturalSorter;
 *   localeCompare('a', 'a') // 0
 *   ```
 */
-/*@__NO_SIDE_EFFECTS__*/
 function localeCompare(x, y) {
-	if (_localeCompare === void 0) _localeCompare = new Intl.Collator().compare;
-	return _localeCompare(x, y);
+	if (cachedLocaleCompare === void 0) cachedLocaleCompare = new require_primordials_intl.IntlCollator().compare;
+	return cachedLocaleCompare(x, y);
 }
 /**
 * Compare two strings using natural sorting (numeric-aware, case-insensitive).
@@ -38,13 +38,12 @@ function localeCompare(x, y) {
 *   naturalCompare('img10', 'img2') // positive (img10 after img2)
 *   ```
 */
-/*@__NO_SIDE_EFFECTS__*/
 function naturalCompare(x, y) {
-	if (_naturalCompare === void 0) _naturalCompare = new Intl.Collator(void 0, {
+	if (cachedNaturalCompare === void 0) cachedNaturalCompare = new require_primordials_intl.IntlCollator(void 0, {
 		numeric: true,
 		sensitivity: "base"
 	}).compare;
-	return _naturalCompare(x, y);
+	return cachedNaturalCompare(x, y);
 }
 /**
 * Sort an array using natural comparison.
@@ -55,10 +54,9 @@ function naturalCompare(x, y) {
 *   // ['file1', 'file2', 'file10']
 *   ```
 */
-/*@__NO_SIDE_EFFECTS__*/
 function naturalSorter(arrayToSort) {
-	if (_naturalSorter === void 0) _naturalSorter = (/* @__PURE__ */ require_sorts__internal.getFastSort()).createNewSortInstance({ comparer: naturalCompare });
-	return _naturalSorter(arrayToSort);
+	if (cachedNaturalSorter === void 0) cachedNaturalSorter = require_sorts__internal.getFastSort().createNewSortInstance({ comparer: naturalCompare });
+	return cachedNaturalSorter(arrayToSort);
 }
 
 //#endregion

package/dist/sorts/semver.js

@@ -18,10 +18,9 @@ const require_sorts__internal = require('./_internal.js');
 *   compareSemver('1.0.0', '1.0.0') // 0
 *   ```
 */
-/*@__NO_SIDE_EFFECTS__*/
 function compareSemver(a, b) {
 	/* c8 ignore start */
-	const semver = /* @__PURE__ */ require_sorts__internal.getSemver();
+	const semver = require_sorts__internal.getSemver();
 	const validA = semver.valid(a);
 	/* c8 ignore stop */
 	const validB = semver.valid(b);

package/dist/sorts/strings.js

@@ -18,7 +18,6 @@ Object.defineProperty(exports, Symbol.toStringTag, { value: 'Module' });
 *   compareStr('a', 'a') // 0
 *   ```
 */
-/*@__NO_SIDE_EFFECTS__*/
 function compareStr(a, b) {
 	return a < b ? -1 : a > b ? 1 : 0;
 }

package/dist/sorts/types.d.ts

@@ -3,5 +3,5 @@
  *   shape returned by `naturalSorter`. Pure types, no runtime side effects.
  */
 import type * as fastSortType from '../external/fast-sort';
-export type FastSortFunction = ReturnType<typeof import('fast-sort').createNewSortInstance>;
+export type FastSortFunction = ReturnType<typeof fastSortType.createNewSortInstance>;
 export type { fastSortType };

package/dist/spinner/create-spinner-class.d.ts

@@ -0,0 +1,38 @@
+/**
+ * @file Builds the lazy-init Socket `Spinner` class that extends the live
+ *   `yocto-spinner` constructor. The class graph is constructed inside
+ *   `createSpinnerClass()` so the `super()` call binds against the runtime
+ *   `YoctoSpinner` constructor passed in by the factory; keeping it here
+ *   (rather than at module scope) preserves the spinner's lazy-init guarantee
+ *   while splitting the bulk of the class body out of the factory module.
+ */
+import type { ColorRgb, ColorValue } from '../colors/types';
+import { incLogCallCountSymbol, lastWasBlankSymbol } from '../logger/symbols';
+import type { SpinnerInstance, SpinnerOptions } from './types';
+export type SpinnerCtorType = {
+    new (options?: SpinnerOptions | undefined): SpinnerInstance;
+};
+export type YoctoSpinnerConstructor = new (...args: unknown[]) => {
+    get color(): ColorRgb | ColorValue;
+    set color(value: ColorRgb | ColorValue);
+    isSpinning: boolean;
+    [key: string]: unknown;
+};
+export type SpinnerLogger = {
+    error: (...args: unknown[]) => unknown;
+    log: (...args: unknown[]) => unknown;
+    [lastWasBlankSymbol]: (value: boolean) => unknown;
+    [incLogCallCountSymbol]: () => unknown;
+};
+/**
+ * Build the Socket `Spinner` class as a subclass of the live `yocto-spinner`
+ * constructor. Passing the parent class in keeps the `super()` binding against
+ * the runtime constructor while letting the bulk of the class body live outside
+ * the factory module.
+ *
+ * @param YoctoSpinnerClass - Runtime `yocto-spinner` constructor to extend.
+ * @param logger - Default logger used for status output.
+ *
+ * @returns The constructed Socket spinner constructor.
+ */
+export declare function createSpinnerClass(YoctoSpinnerClass: YoctoSpinnerConstructor, logger: SpinnerLogger): SpinnerCtorType;

package/dist/spinner/create-spinner-class.js

@@ -0,0 +1,302 @@
+"use strict";
+/* Socket Lib - Built with rolldown */
+Object.defineProperty(exports, Symbol.toStringTag, { value: 'Module' });
+const require_primordials_math = require('../primordials/math.js');
+const require_primordials_array = require('../primordials/array.js');
+const require_primordials_object = require('../primordials/object.js');
+const require_logger_symbols = require('../logger/symbols.js');
+const require_strings_predicates = require('../strings/predicates.js');
+const require_process_abort = require('../process/abort.js');
+const require_colors_convert = require('../colors/convert.js');
+const require_strings_width = require('../strings/width.js');
+const require_spinner_format = require('./format.js');
+const require_spinner_spinner_internals = require('./spinner-internals.js');
+const require_spinner_spinner_shimmer_methods = require('./spinner-shimmer-methods.js');
+const require_spinner_spinner_status_methods = require('./spinner-status-methods.js');
+
+//#region src/spinner/create-spinner-class.ts
+/**
+* Build the Socket `Spinner` class as a subclass of the live `yocto-spinner`
+* constructor. Passing the parent class in keeps the `super()` binding against
+* the runtime constructor while letting the bulk of the class body live outside
+* the factory module.
+*
+* @param YoctoSpinnerClass - Runtime `yocto-spinner` constructor to extend.
+* @param logger - Default logger used for status output.
+*
+* @returns The constructed Socket spinner constructor.
+*/
+function createSpinnerClass(YoctoSpinnerClass, logger) {
+	const SpinnerCtor = class SpinnerClass extends YoctoSpinnerClass {
+		#baseText = "";
+		#indentation = "";
+		#progress;
+		#shimmer;
+		#shimmerSavedConfig;
+		constructor(ctorOptions) {
+			const opts = {
+				__proto__: null,
+				...ctorOptions
+			};
+			const spinnerColorRgb = require_spinner_spinner_internals.resolveSpinnerColorRgb(opts);
+			const shimmerInfo = require_spinner_spinner_internals.parseShimmerOption(opts.shimmer);
+			super({
+				signal: require_process_abort.getAbortSignal(),
+				...opts,
+				color: spinnerColorRgb,
+				onRenderFrame: (frame, text, applyColor) => {
+					const spacing = require_strings_width.stringWidth(frame) === 1 ? "  " : " ";
+					return frame ? `${applyColor(frame)}${spacing}${text}` : text;
+				},
+				onFrameUpdate: shimmerInfo ? () => {
+					if (this.#baseText) super["text"] = this.#buildDisplayText();
+				} : void 0
+			});
+			this.#shimmer = shimmerInfo;
+			this.#shimmerSavedConfig = shimmerInfo;
+		}
+		get color() {
+			const value = super.color;
+			return require_colors_convert.isRgbTuple(value) ? value : require_colors_convert.toRgb(value);
+		}
+		set color(value) {
+			super.color = require_colors_convert.isRgbTuple(value) ? value : require_colors_convert.toRgb(value);
+		}
+		/**
+		* Apply a yocto-spinner method and update logger state. Handles text
+		* normalization, extra arguments, and logger tracking. Exposed under
+		* `applyStatusSymbol` so the status methods installed from
+		* `spinner-status-methods.ts` can drive it.
+		*/
+		[require_spinner_spinner_status_methods.applyStatusSymbol](methodName, args) {
+			let extras;
+			let text = require_primordials_array.ArrayPrototypeAt(args, 0);
+			if (typeof text === "string") extras = require_primordials_array.ArrayPrototypeSlice(args, 1);
+			else {
+				extras = args;
+				text = "";
+			}
+			const wasSpinning = this.isSpinning;
+			const normalized = require_spinner_format.normalizeText(text);
+			const superMethod = super[methodName];
+			if (methodName === "stop" && !normalized) superMethod.call(this);
+			else superMethod.call(this, normalized);
+			if (methodName === "stop") {
+				if (wasSpinning && normalized) {
+					logger[require_logger_symbols.lastWasBlankSymbol](require_strings_predicates.isBlankString(normalized));
+					logger[require_logger_symbols.incLogCallCountSymbol]();
+				}
+			} else {
+				logger[require_logger_symbols.lastWasBlankSymbol](false);
+				logger[require_logger_symbols.incLogCallCountSymbol]();
+			}
+			/* c8 ignore start - extras-empty no-op arm fires when log called without extras */
+			if (extras.length) {
+				logger.log(...extras);
+				logger[require_logger_symbols.lastWasBlankSymbol](false);
+			}
+			/* c8 ignore stop */
+			return this;
+		}
+		/**
+		* Build the complete display text with progress, shimmer, and indentation.
+		* Combines base text, progress bar, shimmer effects, and indentation.
+		*
+		* @private
+		*/
+		#buildDisplayText() {
+			let displayText = this.#baseText;
+			/* c8 ignore start - progress + shimmer paths fire only when caller seeded those configs */
+			if (this.#progress) {
+				const progressText = require_spinner_format.formatProgress(this.#progress);
+				displayText = displayText ? `${displayText} ${progressText}` : progressText;
+			}
+			if (displayText && this.#shimmer) displayText = require_spinner_spinner_internals.applyShimmer(displayText, this.#shimmer, this.color);
+			if (this.#indentation && displayText) displayText = this.#indentation + displayText;
+			/* c8 ignore stop */
+			return displayText;
+		}
+		/**
+		* Show a status message without stopping the spinner. Outputs the symbol
+		* and message to stderr, then continues spinning. Exposed under
+		* `showStatusSymbol` so the status methods installed from
+		* `spinner-status-methods.ts` can drive it.
+		*/
+		[require_spinner_spinner_status_methods.showStatusSymbol](symbolType, args) {
+			let text = require_primordials_array.ArrayPrototypeAt(args, 0);
+			let extras;
+			if (typeof text === "string") extras = require_primordials_array.ArrayPrototypeSlice(args, 1);
+			else {
+				extras = args;
+				text = "";
+			}
+			logger.error(`${require_logger_symbols.LOG_SYMBOLS[symbolType]} ${text}`, ...extras);
+			return this;
+		}
+		/**
+		* Update the spinner's displayed text. Rebuilds display text and triggers
+		* render.
+		*
+		* @private
+		*/
+		#updateSpinnerText() {
+			super["text"] = this.#buildDisplayText();
+		}
+		[require_spinner_spinner_shimmer_methods.getShimmerSymbol]() {
+			return this.#shimmer;
+		}
+		[require_spinner_spinner_shimmer_methods.setShimmerSymbol](value) {
+			this.#shimmer = value;
+		}
+		[require_spinner_spinner_shimmer_methods.getSavedShimmerSymbol]() {
+			return this.#shimmerSavedConfig;
+		}
+		[require_spinner_spinner_shimmer_methods.setSavedShimmerSymbol](value) {
+			this.#shimmerSavedConfig = value;
+		}
+		[require_spinner_spinner_shimmer_methods.updateTextSymbol]() {
+			this.#updateSpinnerText();
+		}
+		/**
+		* Decrease indentation level by removing spaces from the left. Pass 0 to
+		* reset indentation to zero completely.
+		*
+		* @default spaces=2
+		*
+		* @param spaces - Number of spaces to remove.
+		*
+		* @returns This spinner for chaining
+		*/
+		dedent(spaces) {
+			if (spaces === 0) this.#indentation = "";
+			else {
+				const amount = spaces ?? 2;
+				const newLength = require_primordials_math.MathMax(0, this.#indentation.length - amount);
+				this.#indentation = this.#indentation.slice(0, newLength);
+			}
+			this.#updateSpinnerText();
+			return this;
+		}
+		/**
+		* Increase indentation level by adding spaces to the left. Pass 0 to reset
+		* indentation to zero completely.
+		*
+		* @default spaces=2
+		*
+		* @param spaces - Number of spaces to add.
+		*
+		* @returns This spinner for chaining
+		*/
+		indent(spaces) {
+			/* c8 ignore start - spaces===0 fires when caller passes 0; else-branch + default fire for omitted/non-zero */
+			if (spaces === 0) this.#indentation = "";
+			else {
+				const amount = spaces ?? 2;
+				this.#indentation += " ".repeat(amount);
+			}
+			/* c8 ignore stop */
+			this.#updateSpinnerText();
+			return this;
+		}
+		/**
+		* Update progress information displayed with the spinner. Shows a progress
+		* bar with percentage and optional unit label.
+		*
+		* @param current - Current progress value.
+		* @param total - Total/maximum progress value.
+		* @param unit - Optional unit label (e.g., 'files', 'items')
+		*
+		* @returns This spinner for chaining
+		*/
+		progress = (current, total, unit) => {
+			this.#progress = {
+				__proto__: null,
+				current,
+				total,
+				...unit ? { unit } : {}
+			};
+			this.#updateSpinnerText();
+			return this;
+		};
+		/**
+		* Increment progress by a specified amount. Updates the progress bar
+		* displayed with the spinner. Clamps the result between 0 and the total
+		* value.
+		*
+		* @default amount=1
+		*
+		* @param amount - Amount to increment by.
+		*
+		* @returns This spinner for chaining
+		*/
+		progressStep(amount = 1) {
+			/* c8 ignore start - no-progress no-op fires before progress() seed; unit-spread arm fires when seeded with unit */
+			if (this.#progress) {
+				const newCurrent = this.#progress.current + amount;
+				this.#progress = {
+					__proto__: null,
+					current: require_primordials_math.MathMax(0, Math.min(newCurrent, this.#progress.total)),
+					total: this.#progress.total,
+					...this.#progress.unit ? { unit: this.#progress.unit } : {}
+				};
+				this.#updateSpinnerText();
+			}
+			return this;
+			/* c8 ignore stop */
+		}
+		/**
+		* Start the spinner animation with optional text. Begins displaying the
+		* animated spinner on stderr.
+		*
+		* @param text - Optional text to display with the spinner.
+		*
+		* @returns This spinner for chaining
+		*/
+		start(...args) {
+			/* c8 ignore start - args-length and normalized-falsy arms exercised across calls; some test paths skip both */
+			if (args.length) {
+				const normalized = require_spinner_format.normalizeText(require_primordials_array.ArrayPrototypeAt(args, 0));
+				if (!normalized) {
+					this.#baseText = "";
+					super["text"] = "";
+				} else this.#baseText = normalized;
+			}
+			/* c8 ignore stop */
+			this.#updateSpinnerText();
+			return this[require_spinner_spinner_status_methods.applyStatusSymbol]("start", []);
+		}
+		/**
+		* Stop the spinner animation and clear internal state. Auto-clears the
+		* spinner line via yocto-spinner.stop(). Resets progress, shimmer, and text
+		* state.
+		*
+		* @param text - Optional final text to display after stopping.
+		*
+		* @returns This spinner for chaining
+		*/
+		stop(...args) {
+			this.#baseText = "";
+			this.#progress = void 0;
+			this.#shimmer = void 0;
+			return this[require_spinner_spinner_status_methods.applyStatusSymbol]("stop", args);
+		}
+		text(value) {
+			if (arguments.length === 0) return this.#baseText;
+			this.#baseText = value ?? "";
+			this.#updateSpinnerText();
+			return this;
+		}
+	};
+	require_spinner_spinner_status_methods.installStatusMethods(SpinnerCtor.prototype, logger);
+	require_spinner_spinner_shimmer_methods.installShimmerMethods(SpinnerCtor.prototype);
+	require_primordials_object.ObjectDefineProperties(SpinnerCtor.prototype, {
+		error: require_spinner_format.desc(SpinnerCtor.prototype.fail),
+		errorAndStop: require_spinner_format.desc(SpinnerCtor.prototype.failAndStop),
+		warning: require_spinner_format.desc(SpinnerCtor.prototype.warn),
+		warningAndStop: require_spinner_format.desc(SpinnerCtor.prototype.warnAndStop)
+	});
+	return SpinnerCtor;
+}
+
+//#endregion
+exports.createSpinnerClass = createSpinnerClass;