astro 5.5.1 → 5.5.3

package/dist/cli/add/index.js

@@ -117,7 +117,7 @@ async function add(names, { flags }) {
   const cwd = inlineConfig.root;
   const logger = createLoggerFromFlags(flags);
   const integrationNames = names.map((name) => ALIASES.has(name) ? ALIASES.get(name) : name);
-  const integrations = await validateIntegrations(integrationNames);
+  const integrations = await validateIntegrations(integrationNames, flags);
   let installResult = await tryToInstallIntegrations({ integrations, cwd, flags, logger });
   const rootPath = resolveRoot(cwd);
   const root = pathToFileURL(rootPath);
@@ -585,7 +585,7 @@ ${message}`
     return 2 /* cancelled */;
   }
 }
-async function validateIntegrations(integrations) {
+async function validateIntegrations(integrations, flags) {
   const spinner = yoctoSpinner({ text: "Resolving packages..." }).start();
   try {
     const integrationEntries = await Promise.all(
@@ -606,13 +606,7 @@ async function validateIntegrations(integrations) {
               spinner.warning(yellow(firstPartyPkgCheck.message));
             }
             spinner.warning(yellow(`${bold(integration)} is not an official Astro package.`));
-            const response = await prompts({
-              type: "confirm",
-              name: "askToContinue",
-              message: "Continue?",
-              initial: true
-            });
-            if (!response.askToContinue) {
+            if (!await askToContinue({ flags })) {
               throw new Error(
                 `No problem! Find our official integrations at ${cyan(
                   "https://astro.build/integrations"

package/dist/container/index.d.ts

@@ -243,4 +243,15 @@ export declare class experimental_AstroContainer {
      * @param {ContainerRenderOptions=} options Possible options to pass when rendering the component.
      */
     renderToResponse(component: AstroComponentFactory, options?: ContainerRenderOptions): Promise<Response>;
+    /**
+     * It stores an Astro **page** route. The first argument, `route`, gets associated to the `component`.
+     *
+     * This function can be useful when you want to render a route via `AstroContainer.renderToString`, where that
+     * route eventually renders another route via `Astro.rewrite`.
+     *
+     * @param {string} route - The URL that will render the component.
+     * @param {AstroComponentFactory} component - The component factory to be used for rendering the route.
+     * @param {Record<string, string | undefined>} params - An object containing key-value pairs of route parameters.
+     */
+    insertPageRoute(route: string, component: AstroComponentFactory, params?: Record<string, string | undefined>): void;
 }

package/dist/container/index.js

@@ -12,6 +12,7 @@ import { RenderContext } from "../core/render-context.js";
 import { getParts } from "../core/routing/manifest/parts.js";
 import { getPattern } from "../core/routing/manifest/pattern.js";
 import { validateSegment } from "../core/routing/manifest/segment.js";
+import { SlotString } from "../runtime/server/render/slot.js";
 import { ContainerPipeline } from "./pipeline.js";
 function createManifest(manifest, renderers, middleware) {
   function middlewareInstance() {
@@ -234,6 +235,9 @@ class experimental_AstroContainer {
    * @param {ContainerRenderOptions=} options Possible options to pass when rendering the component.
    */
   async renderToString(component, options = {}) {
+    if (options.slots) {
+      options.slots = markAllSlotsAsSlotString(options.slots);
+    }
     const response = await this.renderToResponse(component, options);
     return await response.text();
   }
@@ -285,6 +289,29 @@ class experimental_AstroContainer {
     }
     return renderContext.render(componentInstance, slots);
   }
+  /**
+   * It stores an Astro **page** route. The first argument, `route`, gets associated to the `component`.
+   *
+   * This function can be useful when you want to render a route via `AstroContainer.renderToString`, where that
+   * route eventually renders another route via `Astro.rewrite`.
+   *
+   * @param {string} route - The URL that will render the component.
+   * @param {AstroComponentFactory} component - The component factory to be used for rendering the route.
+   * @param {Record<string, string | undefined>} params - An object containing key-value pairs of route parameters.
+   */
+  insertPageRoute(route, component, params) {
+    const url = new URL(route, "https://example.com/");
+    const routeData = this.#createRoute(url, params ?? {}, "page");
+    this.#pipeline.manifest.routes.push({
+      routeData,
+      file: "",
+      links: [],
+      styles: [],
+      scripts: []
+    });
+    const componentInstance = this.#wrapComponent(component, params);
+    this.#pipeline.insertRoute(routeData, componentInstance);
+  }
   #createRoute(url, params, type) {
     const segments = removeLeadingForwardSlash(url.pathname).split(posix.sep).filter(Boolean).map((s) => {
       validateSegment(s);
@@ -331,6 +358,13 @@ class experimental_AstroContainer {
 function isNamedRenderer(renderer) {
   return !!renderer?.name;
 }
+function markAllSlotsAsSlotString(slots) {
+  const markedSlots = {};
+  for (const slotName in slots) {
+    markedSlots[slotName] = new SlotString(slots[slotName], null);
+  }
+  return markedSlots;
+}
 export {
   experimental_AstroContainer
 };

package/dist/container/pipeline.d.ts

@@ -9,5 +9,5 @@ export declare class ContainerPipeline extends Pipeline {
     headElements(routeData: RouteData): Promise<HeadElements> | HeadElements;
     tryRewrite(payload: RewritePayload, request: Request): Promise<TryRewriteResult>;
     insertRoute(route: RouteData, componentInstance: ComponentInstance): void;
-    getComponentByRoute(_routeData: RouteData): Promise<ComponentInstance>;
+    getComponentByRoute(routeData: RouteData): Promise<ComponentInstance>;
 }

package/dist/container/pipeline.js

@@ -71,8 +71,12 @@ class ContainerPipeline extends Pipeline {
     });
   }
   // At the moment it's not used by the container via any public API
-  // @ts-expect-error It needs to be implemented.
-  async getComponentByRoute(_routeData) {
+  async getComponentByRoute(routeData) {
+    const page = this.#componentsInterner.get(routeData);
+    if (page) {
+      return page.page();
+    }
+    throw new Error("Couldn't find component for route " + routeData.pathname);
   }
 }
 export {

package/dist/content/content-layer.js

@@ -153,7 +153,7 @@ ${contentConfig.error.message}`);
       logger.info("Content config changed");
       shouldClear = true;
     }
-    if (previousAstroVersion && previousAstroVersion !== "5.5.1") {
+    if (previousAstroVersion && previousAstroVersion !== "5.5.3") {
       logger.info("Astro version changed");
       shouldClear = true;
     }
@@ -161,8 +161,8 @@ ${contentConfig.error.message}`);
       logger.info("Clearing content store");
       this.#store.clearAll();
     }
-    if ("5.5.1") {
-      await this.#store.metaStore().set("astro-version", "5.5.1");
+    if ("5.5.3") {
+      await this.#store.metaStore().set("astro-version", "5.5.3");
     }
     if (currentConfigDigest) {
       await this.#store.metaStore().set("content-config-digest", currentConfigDigest);
@@ -223,11 +223,11 @@ ${contentConfig.error.message}`);
     );
     await fs.mkdir(this.#settings.config.cacheDir, { recursive: true });
     await fs.mkdir(this.#settings.dotAstroDir, { recursive: true });
-    await this.#store.writeToDisk();
     const assetImportsFile = new URL(ASSET_IMPORTS_FILE, this.#settings.dotAstroDir);
     await this.#store.writeAssetImports(assetImportsFile);
     const modulesImportsFile = new URL(MODULES_IMPORTS_FILE, this.#settings.dotAstroDir);
     await this.#store.writeModuleImports(modulesImportsFile);
+    await this.#store.waitUntilSaveComplete();
     logger.info("Synced content");
     if (this.#settings.config.experimental.contentIntellisense) {
       await this.regenerateCollectionFileManifest();

package/dist/content/mutable-data-store.d.ts

@@ -20,6 +20,11 @@ export declare class MutableDataStore extends ImmutableDataStore {
      * Returns a MetaStore for a given collection, or if no collection is provided, the default meta collection.
      */
     metaStore(collectionName?: string): MetaStore;
+    /**
+     * Returns a promise that resolves when all pending saves are complete.
+     * This includes any in-progress debounced saves for the data store, asset imports, and module imports.
+     */
+    waitUntilSaveComplete(): Promise<void>;
     toString(): string;
     writeToDisk(): Promise<void>;
     /**

package/dist/content/mutable-data-store.js

@@ -15,6 +15,8 @@ class MutableDataStore extends ImmutableDataStore {
   #saveTimeout;
   #assetsSaveTimeout;
   #modulesSaveTimeout;
+  #savePromise;
+  #savePromiseResolve;
   #dirty = false;
   #assetsDirty = false;
   #modulesDirty = false;
@@ -118,15 +120,28 @@ ${lines.join(",\n")}]);
     }
     this.#modulesDirty = false;
   }
+  #maybeResolveSavePromise() {
+    if (!this.#saveTimeout && !this.#assetsSaveTimeout && !this.#modulesSaveTimeout && this.#savePromiseResolve) {
+      this.#savePromiseResolve();
+      this.#savePromiseResolve = void 0;
+      this.#savePromise = void 0;
+    }
+  }
   #writeAssetsImportsDebounced() {
     this.#assetsDirty = true;
     if (this.#assetsFile) {
       if (this.#assetsSaveTimeout) {
         clearTimeout(this.#assetsSaveTimeout);
       }
-      this.#assetsSaveTimeout = setTimeout(() => {
+      if (!this.#savePromise) {
+        this.#savePromise = new Promise((resolve) => {
+          this.#savePromiseResolve = resolve;
+        });
+      }
+      this.#assetsSaveTimeout = setTimeout(async () => {
         this.#assetsSaveTimeout = void 0;
-        this.writeAssetImports(this.#assetsFile);
+        await this.writeAssetImports(this.#assetsFile);
+        this.#maybeResolveSavePromise();
       }, SAVE_DEBOUNCE_MS);
     }
   }
@@ -136,22 +151,45 @@ ${lines.join(",\n")}]);
       if (this.#modulesSaveTimeout) {
         clearTimeout(this.#modulesSaveTimeout);
       }
-      this.#modulesSaveTimeout = setTimeout(() => {
+      if (!this.#savePromise) {
+        this.#savePromise = new Promise((resolve) => {
+          this.#savePromiseResolve = resolve;
+        });
+      }
+      this.#modulesSaveTimeout = setTimeout(async () => {
         this.#modulesSaveTimeout = void 0;
-        this.writeModuleImports(this.#modulesFile);
+        await this.writeModuleImports(this.#modulesFile);
+        this.#maybeResolveSavePromise();
       }, SAVE_DEBOUNCE_MS);
     }
   }
+  // Skips the debounce and writes to disk immediately
+  async #saveToDiskNow() {
+    if (this.#saveTimeout) {
+      clearTimeout(this.#saveTimeout);
+    }
+    this.#saveTimeout = void 0;
+    if (this.#file) {
+      await this.writeToDisk();
+    }
+    this.#maybeResolveSavePromise();
+  }
   #saveToDiskDebounced() {
     this.#dirty = true;
     if (this.#saveTimeout) {
       clearTimeout(this.#saveTimeout);
     }
-    this.#saveTimeout = setTimeout(() => {
+    if (!this.#savePromise) {
+      this.#savePromise = new Promise((resolve) => {
+        this.#savePromiseResolve = resolve;
+      });
+    }
+    this.#saveTimeout = setTimeout(async () => {
       this.#saveTimeout = void 0;
       if (this.#file) {
-        this.writeToDisk();
+        await this.writeToDisk();
       }
+      this.#maybeResolveSavePromise();
     }, SAVE_DEBOUNCE_MS);
   }
   #writing = /* @__PURE__ */ new Set();
@@ -271,6 +309,17 @@ ${lines.join(",\n")}]);
       has: (key) => this.has(collectionKey, key)
     };
   }
+  /**
+   * Returns a promise that resolves when all pending saves are complete.
+   * This includes any in-progress debounced saves for the data store, asset imports, and module imports.
+   */
+  async waitUntilSaveComplete() {
+    if (!this.#savePromise) {
+      return Promise.resolve();
+    }
+    await this.#saveToDiskNow();
+    return this.#savePromise;
+  }
   toString() {
     return devalue.stringify(this._collections);
   }
@@ -282,8 +331,8 @@ ${lines.join(",\n")}]);
       throw new AstroError(AstroErrorData.UnknownFilesystemError);
     }
     try {
-      await this.#writeFileAtomic(this.#file, this.toString());
       this.#dirty = false;
+      await this.#writeFileAtomic(this.#file, this.toString());
     } catch (err) {
       throw new AstroError(AstroErrorData.UnknownFilesystemError, { cause: err });
     }

package/dist/content/runtime.js

@@ -450,8 +450,6 @@ async function render({
   }
 }
 function createReference({ lookupMap }) {
-  let store = null;
-  globalDataStore.get().then((s) => store = s);
   return function reference(collection) {
     return z.union([
       z.string(),
@@ -465,14 +463,6 @@ function createReference({ lookupMap }) {
       })
     ]).transform(
       (lookup, ctx) => {
-        if (!store) {
-          ctx.addIssue({
-            code: ZodIssueCode.custom,
-            message: `**${ctx.path.join(".")}:** Reference to ${collection} could not be resolved: store not available.
-This is an Astro bug, so please file an issue at https://github.com/withastro/astro/issues.`
-          });
-          return;
-        }
         const flattenedErrorPath = ctx.path.join(".");
         if (typeof lookup === "object") {
           if (lookup.collection !== collection) {

package/dist/core/app/node.js

@@ -39,13 +39,20 @@ class NodeApp extends App {
       return multiValueHeader?.toString()?.split(",").map((e) => e.trim())?.[0];
     };
     const forwardedProtocol = getFirstForwardedValue(req.headers["x-forwarded-proto"]);
-    const protocol = forwardedProtocol ?? (isEncrypted ? "https" : "http");
+    const providedProtocol = isEncrypted ? "https" : "http";
+    const protocol = forwardedProtocol ?? providedProtocol;
     const forwardedHostname = getFirstForwardedValue(req.headers["x-forwarded-host"]);
-    const hostname = forwardedHostname ?? req.headers.host ?? req.headers[":authority"];
+    const providedHostname = req.headers.host ?? req.headers[":authority"];
+    const hostname = forwardedHostname ?? providedHostname;
     const port = getFirstForwardedValue(req.headers["x-forwarded-port"]);
-    const portInHostname = typeof hostname === "string" && /:\d+$/.test(hostname);
-    const hostnamePort = portInHostname ? hostname : `${hostname}${port ? `:${port}` : ""}`;
-    const url = `${protocol}://${hostnamePort}${req.url}`;
+    let url;
+    try {
+      const hostnamePort = getHostnamePort(hostname, port);
+      url = new URL(`${protocol}://${hostnamePort}${req.url}`);
+    } catch {
+      const hostnamePort = getHostnamePort(providedHostname, port);
+      url = new URL(`${providedProtocol}://${hostnamePort}`);
+    }
     const options = {
       method: req.method || "GET",
       headers: makeRequestHeaders(req)
@@ -107,6 +114,11 @@ class NodeApp extends App {
     }
   }
 }
+function getHostnamePort(hostname, port) {
+  const portInHostname = typeof hostname === "string" && /:\d+$/.test(hostname);
+  const hostnamePort = portInHostname ? hostname : `${hostname}${port ? `:${port}` : ""}`;
+  return hostnamePort;
+}
 function makeRequestHeaders(req) {
   const headers = new Headers();
   for (const [name, value] of Object.entries(req.headers)) {

package/dist/core/build/plugins/plugin-css.js

@@ -101,6 +101,22 @@ function rollupPluginAstroBuildCSS(options) {
       }
     }
   };
+  const cssScopeToPlugin = {
+    name: "astro:rollup-plugin-css-scope-to",
+    renderChunk(_, chunk, __, meta) {
+      for (const id in chunk.modules) {
+        const modMeta = this.getModuleInfo(id)?.meta;
+        const cssScopeTo = modMeta?.astroCss?.cssScopeTo;
+        if (cssScopeTo && !isCssScopeToRendered(cssScopeTo, Object.values(meta.chunks))) {
+          delete chunk.modules[id];
+          const moduleIdsIndex = chunk.moduleIds.indexOf(id);
+          if (moduleIdsIndex > -1) {
+            chunk.moduleIds.splice(moduleIdsIndex, 1);
+          }
+        }
+      }
+    }
+  };
   const singleCssPlugin = {
     name: "astro:rollup-plugin-single-css",
     enforce: "post",
@@ -162,7 +178,7 @@ function rollupPluginAstroBuildCSS(options) {
       });
     }
   };
-  return [cssBuildPlugin, singleCssPlugin, inlineStylesheetsPlugin];
+  return [cssBuildPlugin, cssScopeToPlugin, singleCssPlugin, inlineStylesheetsPlugin];
 }
 function* getParentClientOnlys(id, ctx, internals) {
   for (const info of getParentModuleInfos(id, ctx)) {
@@ -187,6 +203,16 @@ function appendCSSToPage(pageData, meta, pagesToCss, depth, order) {
     }
   }
 }
+function isCssScopeToRendered(cssScopeTo, chunks) {
+  for (const moduleId in cssScopeTo) {
+    const exports = cssScopeTo[moduleId];
+    const renderedModule = chunks.find((c) => c.moduleIds.includes(moduleId))?.modules[moduleId];
+    if (renderedModule?.renderedExports.some((e) => exports.includes(e))) {
+      return true;
+    }
+  }
+  return false;
+}
 export {
   pluginCSS
 };

package/dist/core/build/static-build.js

@@ -137,15 +137,7 @@ async function ssrBuild(opts, internals, input, container) {
             const encoded = encodeName(name);
             return [prefix, encoded, suffix].join("");
           },
-          assetFileNames(chunkInfo) {
-            const { names } = chunkInfo;
-            const name = names[0] ?? "";
-            if (name.includes(ASTRO_PAGE_EXTENSION_POST_PATTERN)) {
-              const [sanitizedName] = name.split(ASTRO_PAGE_EXTENSION_POST_PATTERN);
-              return `${settings.config.build.assets}/${sanitizedName}.[hash][extname]`;
-            }
-            return `${settings.config.build.assets}/[name].[hash][extname]`;
-          },
+          assetFileNames: `${settings.config.build.assets}/[name].[hash][extname]`,
           ...viteConfig.build?.rollupOptions?.output,
           entryFileNames(chunkInfo) {
             if (chunkInfo.facadeModuleId?.startsWith(ASTRO_PAGE_RESOLVED_MODULE_ID)) {

package/dist/core/config/merge.js

@@ -26,6 +26,9 @@ function mergeConfigRecursively(defaults, overrides, rootPath) {
         continue;
       }
     }
+    if (key === "allowedHosts" && rootPath === "server" && typeof existing === "boolean") {
+      continue;
+    }
     if (key === "data" && rootPath === "db") {
       if (!Array.isArray(existing) && !Array.isArray(value)) {
         existing = [existing];

package/dist/core/constants.js

@@ -1,4 +1,4 @@
-const ASTRO_VERSION = "5.5.1";
+const ASTRO_VERSION = "5.5.3";
 const REROUTE_DIRECTIVE_HEADER = "X-Astro-Reroute";
 const REWRITE_DIRECTIVE_HEADER_KEY = "X-Astro-Rewrite";
 const REWRITE_DIRECTIVE_HEADER_VALUE = "yes";

package/dist/core/dev/dev.js

@@ -22,7 +22,7 @@ async function dev(inlineConfig) {
   await telemetry.record([]);
   const restart = await createContainerWithAutomaticRestart({ inlineConfig, fs });
   const logger = restart.container.logger;
-  const currentVersion = "5.5.1";
+  const currentVersion = "5.5.3";
   const isPrerelease = currentVersion.includes("-");
   if (!isPrerelease) {
     try {

package/dist/core/messages.js

@@ -38,7 +38,7 @@ function serverStart({
   host,
   base
 }) {
-  const version = "5.5.1";
+  const version = "5.5.3";
   const localPrefix = `${dim("\u2503")} Local    `;
   const networkPrefix = `${dim("\u2503")} Network  `;
   const emptyPrefix = " ".repeat(11);
@@ -282,7 +282,7 @@ function printHelp({
     message.push(
       linebreak(),
       `  ${bgGreen(black(` ${commandName} `))} ${green(
-        `v${"5.5.1"}`
+        `v${"5.5.3"}`
       )} ${headline}`
     );
   }

package/dist/core/session.js

@@ -53,6 +53,7 @@ class AstroSession {
   // When we load the data from storage, we need to merge it with the local partial data,
   // preserving in-memory changes and deletions.
   #partial = true;
+  static #sharedStorage = /* @__PURE__ */ new Map();
   constructor(cookies, {
     cookie: cookieConfig = DEFAULT_COOKIE_NAME,
     ...config
@@ -314,6 +315,10 @@ class AstroSession {
     if (this.#storage) {
       return this.#storage;
     }
+    if (AstroSession.#sharedStorage.has(this.#config.driver)) {
+      this.#storage = AstroSession.#sharedStorage.get(this.#config.driver);
+      return this.#storage;
+    }
     if (this.#config.driver === "test") {
       this.#storage = this.#config.options.mockStorage;
       return this.#storage;
@@ -367,6 +372,7 @@ class AstroSession {
       this.#storage = createStorage({
         driver: driver(this.#config.options)
       });
+      AstroSession.#sharedStorage.set(this.#config.driver, this.#storage);
       return this.#storage;
     } catch (err) {
       throw new AstroError(

package/dist/vite-plugin-astro/index.d.ts

@@ -1,9 +1,9 @@
 import type * as vite from 'vite';
 import type { Logger } from '../core/logger/core.js';
 import type { AstroSettings } from '../types/astro.js';
-import type { PluginMetadata as AstroPluginMetadata } from './types.js';
+import type { PluginCssMetadata as AstroPluginCssMetadata, PluginMetadata as AstroPluginMetadata } from './types.js';
 export { getAstroMetadata } from './metadata.js';
-export type { AstroPluginMetadata };
+export type { AstroPluginMetadata, AstroPluginCssMetadata };
 interface AstroPluginOptions {
     settings: AstroSettings;
     logger: Logger;

package/dist/vite-plugin-astro/index.js

@@ -89,9 +89,15 @@ function astro({ settings, logger }) {
           result.dependencies?.forEach((dep) => this.addWatchFile(dep));
           return {
             code: result.code,
-            // `vite.cssScopeTo` is a Vite feature that allows this CSS to be treeshaken
-            // if the Astro component's default export is not used
-            meta: result.isGlobal ? void 0 : { vite: { cssScopeTo: [filename, "default"] } }
+            // This metadata is used by `cssScopeToPlugin` to remove this module from the bundle
+            // if the `filename` default export (the Astro component) is unused.
+            meta: result.isGlobal ? void 0 : {
+              astroCss: {
+                cssScopeTo: {
+                  [filename]: ["default"]
+                }
+              }
+            }
           };
         }
         case "script": {

package/dist/vite-plugin-astro/types.d.ts

@@ -15,6 +15,26 @@ export interface PluginMetadata {
         pageOptions: PageOptions;
     };
 }
+export interface PluginCssMetadata {
+    astroCss: {
+        /**
+         * For Astro CSS virtual modules, it can scope to the main Astro module's default export
+         * so that if those exports are treeshaken away, the CSS module will also be treeshaken.
+         *
+         * Example config if the CSS id is `/src/Foo.astro?astro&type=style&lang.css`:
+         * ```js
+         * cssScopeTo: {
+         *   '/src/Foo.astro': ['default']
+         * }
+         * ```
+         *
+         * The above is the only config we use today, but we're exposing as a `Record` to follow the
+         * upstream Vite implementation: https://github.com/vitejs/vite/pull/16058. When/If that lands,
+         * we can also remove our custom implementation.
+         */
+        cssScopeTo: Record<string, string[]>;
+    };
+}
 export interface CompileMetadata {
     /** Used for HMR to compare code changes */
     originalCode: string;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "astro",
-  "version": "5.5.1",
+  "version": "5.5.3",
   "description": "Astro is a modern site builder with web best practices, performance, and DX front-of-mind.",
   "type": "module",
   "author": "withastro",
@@ -142,7 +142,7 @@
     "prompts": "^2.4.2",
     "rehype": "^13.0.2",
     "semver": "^7.7.1",
-    "shiki": "^1.29.2",
+    "shiki": "^3.0.0",
     "tinyexec": "^0.3.2",
     "tinyglobby": "^0.2.12",
     "tsconfck": "^3.1.5",
@@ -159,7 +159,7 @@
     "zod-to-json-schema": "^3.24.3",
     "zod-to-ts": "^1.2.0",
     "@astrojs/internal-helpers": "0.6.1",
-    "@astrojs/markdown-remark": "6.3.0",
+    "@astrojs/markdown-remark": "6.3.1",
     "@astrojs/telemetry": "3.2.0"
   },
   "optionalDependencies": {