astro 4.13.3 → 4.14.0

package/dist/core/config/schema.js

@@ -47,9 +47,11 @@ const ASTRO_CONFIG_DEFAULTS = {
     clientPrerender: false,
     globalRoutePriority: false,
     serverIslands: false,
+    contentIntellisense: false,
     env: {
       validateSecrets: false
-    }
+    },
+    contentLayer: false
   }
 };
 const AstroConfigSchema = z.object({
@@ -332,7 +334,9 @@ const AstroConfigSchema = z.object({
       schema: EnvSchema.optional(),
       validateSecrets: z.boolean().optional().default(ASTRO_CONFIG_DEFAULTS.experimental.env.validateSecrets)
     }).strict().optional(),
-    serverIslands: z.boolean().optional().default(ASTRO_CONFIG_DEFAULTS.experimental.serverIslands)
+    serverIslands: z.boolean().optional().default(ASTRO_CONFIG_DEFAULTS.experimental.serverIslands),
+    contentIntellisense: z.boolean().optional().default(ASTRO_CONFIG_DEFAULTS.experimental.contentIntellisense),
+    contentLayer: z.boolean().optional().default(ASTRO_CONFIG_DEFAULTS.experimental.contentLayer)
   }).strict(
     `Invalid or outdated experimental feature.
 Check for incorrect spelling or outdated Astro version.

package/dist/core/config/settings.js

@@ -12,7 +12,8 @@ import { AstroTimer } from "./timer.js";
 import { loadTSConfig } from "./tsconfig.js";
 function createBaseSettings(config) {
   const { contentDir } = getContentPaths(config);
-  const preferences = createPreferences(config);
+  const dotAstroDir = new URL(".astro/", config.root);
+  const preferences = createPreferences(config, dotAstroDir);
   return {
     config,
     preferences,
@@ -94,9 +95,10 @@ function createBaseSettings(config) {
     watchFiles: [],
     devToolbarApps: [],
     timer: new AstroTimer(),
-    dotAstroDir: new URL(".astro/", config.root),
-    latestAstroVersion: void 0
+    dotAstroDir,
+    latestAstroVersion: void 0,
     // Will be set later if applicable when the dev server starts
+    injectedTypes: []
   };
 }
 async function createSettings(config, cwd) {

package/dist/core/constants.js

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

package/dist/core/create-vite.js

@@ -102,7 +102,7 @@ async function createVite(commandConfig, { settings, logger, mode, command, fs =
       // The server plugin is for dev only and having it run during the build causes
       // the build to run very slow as the filewatcher is triggered often.
       mode !== "build" && vitePluginAstroServer({ settings, logger, fs }),
-      envVitePlugin({ settings }),
+      envVitePlugin({ settings, logger }),
       astroEnv({ settings, mode, fs, sync }),
       markdownVitePlugin({ settings, logger }),
       htmlVitePlugin(),

package/dist/core/dev/container.js

@@ -49,7 +49,8 @@ async function createContainer({
     logger,
     skip: {
       content: true
-    }
+    },
+    force: inlineConfig?.force
   });
   const viteServer = await vite.createServer(viteConfig);
   const container = {

package/dist/core/dev/dev.js

@@ -1,8 +1,12 @@
-import fs from "node:fs";
+import fs, { existsSync } from "node:fs";
 import { green } from "kleur/colors";
 import { performance } from "perf_hooks";
 import { gt, major, minor, patch } from "semver";
+import { DATA_STORE_FILE } from "../../content/consts.js";
+import { globalContentLayer } from "../../content/content-layer.js";
+import { DataStore, globalDataStore } from "../../content/data-store.js";
 import { attachContentServerListeners } from "../../content/index.js";
+import { globalContentConfigObserver } from "../../content/utils.js";
 import { telemetry } from "../../events/index.js";
 import * as msg from "../messages.js";
 import { ensureProcessNodeEnv } from "../util.js";
@@ -19,7 +23,7 @@ async function dev(inlineConfig) {
   await telemetry.record([]);
   const restart = await createContainerWithAutomaticRestart({ inlineConfig, fs });
   const logger = restart.container.logger;
-  const currentVersion = "4.13.3";
+  const currentVersion = "4.14.0";
   const isPrerelease = currentVersion.includes("-");
   if (!isPrerelease) {
     try {
@@ -64,6 +68,34 @@ async function dev(inlineConfig) {
     logger.warn("SKIP_FORMAT", msg.fsStrictWarning());
   }
   await attachContentServerListeners(restart.container);
+  let store;
+  try {
+    const dataStoreFile = new URL(DATA_STORE_FILE, restart.container.settings.config.cacheDir);
+    if (existsSync(dataStoreFile)) {
+      store = await DataStore.fromFile(dataStoreFile);
+      globalDataStore.set(store);
+    }
+  } catch (err) {
+    logger.error("content", err.message);
+  }
+  if (!store) {
+    store = new DataStore();
+    globalDataStore.set(store);
+  }
+  const config = globalContentConfigObserver.get();
+  if (config.status === "error") {
+    logger.error("content", config.error.message);
+  }
+  if (config.status === "loaded") {
+    const contentLayer = globalContentLayer.init({
+      settings: restart.container.settings,
+      logger,
+      watcher: restart.container.viteServer.watcher,
+      store
+    });
+    contentLayer.watchContentConfig();
+    await contentLayer.sync();
+  }
   logger.info(null, green("watching for file changes..."));
   return {
     address: devServerAddressInfo,

package/dist/core/dev/restart.js

@@ -1,5 +1,6 @@
 import { fileURLToPath } from "node:url";
 import * as vite from "vite";
+import { globalContentLayer } from "../../content/content-layer.js";
 import { eventCliSession, telemetry } from "../../events/index.js";
 import { createNodeLogger, createSettings, resolveConfig } from "../config/index.js";
 import { collectErrorMetadata } from "../errors/dev/utils.js";
@@ -20,16 +21,18 @@ async function createRestartedContainer(container, settings) {
   return newContainer;
 }
 const configRE = /.*astro.config.(?:mjs|cjs|js|ts)$/;
-const preferencesRE = /.*\.astro\/settings.json$/;
 function shouldRestartContainer({ settings, inlineConfig, restartInFlight }, changedFile) {
   if (restartInFlight) return false;
   let shouldRestart = false;
+  const normalizedChangedFile = vite.normalizePath(changedFile);
   if (inlineConfig.configFile) {
-    shouldRestart = vite.normalizePath(inlineConfig.configFile) === vite.normalizePath(changedFile);
+    shouldRestart = vite.normalizePath(inlineConfig.configFile) === normalizedChangedFile;
   } else {
-    const normalizedChangedFile = vite.normalizePath(changedFile);
     shouldRestart = configRE.test(normalizedChangedFile);
-    if (preferencesRE.test(normalizedChangedFile)) {
+    const settingsPath = vite.normalizePath(
+      fileURLToPath(new URL("settings.json", settings.dotAstroDir))
+    );
+    if (settingsPath.endsWith(normalizedChangedFile)) {
       shouldRestart = settings.preferences.ignoreNextPreferenceReload ? false : true;
       settings.preferences.ignoreNextPreferenceReload = false;
     }
@@ -116,13 +119,25 @@ async function createContainerWithAutomaticRestart({
     watcher.on("unlink", handleChangeRestart("Configuration file removed."));
     watcher.on("add", handleChangeRestart("Configuration file added."));
     restart.container.viteServer.restart = () => handleServerRestart();
+    const customShortcuts = [
+      // Disable default Vite shortcuts that don't work well with Astro
+      { key: "r", description: "" },
+      { key: "u", description: "" },
+      { key: "c", description: "" }
+    ];
+    if (restart.container.settings.config.experimental.contentLayer) {
+      customShortcuts.push({
+        key: "s",
+        description: "sync content layer",
+        action: () => {
+          if (globalContentLayer.initialized()) {
+            globalContentLayer.get().sync();
+          }
+        }
+      });
+    }
     restart.container.viteServer.bindCLIShortcuts({
-      customShortcuts: [
-        // Disable Vite's builtin "r" (restart server), "u" (print server urls) and "c" (clear console) shortcuts
-        { key: "r", description: "" },
-        { key: "u", description: "" },
-        { key: "c", description: "" }
-      ]
+      customShortcuts
     });
   }
   setupContainer();

package/dist/core/encryption.d.ts

@@ -0,0 +1,24 @@
+/**
+ * Creates a CryptoKey object that can be used to encrypt any string.
+ */
+export declare function createKey(): Promise<CryptoKey>;
+/**
+ * Takes a key that has been serialized to an array of bytes and returns a CryptoKey
+ */
+export declare function importKey(bytes: Uint8Array): Promise<CryptoKey>;
+/**
+ * Encodes a CryptoKey to base64 string, so that it can be embedded in JSON / JavaScript
+ */
+export declare function encodeKey(key: CryptoKey): Promise<string>;
+/**
+ * Decodes a base64 string into bytes and then imports the key.
+ */
+export declare function decodeKey(encoded: string): Promise<CryptoKey>;
+/**
+ * Using a CryptoKey, encrypt a string into a base64 string.
+ */
+export declare function encryptString(key: CryptoKey, raw: string): Promise<string>;
+/**
+ * Takes a base64 encoded string, decodes it and returns the decrypted text.
+ */
+export declare function decryptString(key: CryptoKey, encoded: string): Promise<string>;

package/dist/core/encryption.js

@@ -0,0 +1,64 @@
+import { decodeBase64, decodeHex, encodeBase64, encodeHexUpperCase } from "@oslojs/encoding";
+const ALGORITHM = "AES-GCM";
+async function createKey() {
+  const key = await crypto.subtle.generateKey(
+    {
+      name: ALGORITHM,
+      length: 256
+    },
+    true,
+    ["encrypt", "decrypt"]
+  );
+  return key;
+}
+async function importKey(bytes) {
+  const key = await crypto.subtle.importKey("raw", bytes, ALGORITHM, true, ["encrypt", "decrypt"]);
+  return key;
+}
+async function encodeKey(key) {
+  const exported = await crypto.subtle.exportKey("raw", key);
+  const encodedKey = encodeBase64(new Uint8Array(exported));
+  return encodedKey;
+}
+async function decodeKey(encoded) {
+  const bytes = decodeBase64(encoded);
+  return crypto.subtle.importKey("raw", bytes, ALGORITHM, true, ["encrypt", "decrypt"]);
+}
+const encoder = new TextEncoder();
+const decoder = new TextDecoder();
+const IV_LENGTH = 24;
+async function encryptString(key, raw) {
+  const iv = crypto.getRandomValues(new Uint8Array(IV_LENGTH / 2));
+  const data = encoder.encode(raw);
+  const buffer = await crypto.subtle.encrypt(
+    {
+      name: ALGORITHM,
+      iv
+    },
+    key,
+    data
+  );
+  return encodeHexUpperCase(iv) + encodeBase64(new Uint8Array(buffer));
+}
+async function decryptString(key, encoded) {
+  const iv = decodeHex(encoded.slice(0, IV_LENGTH));
+  const dataArray = decodeBase64(encoded.slice(IV_LENGTH));
+  const decryptedBuffer = await crypto.subtle.decrypt(
+    {
+      name: ALGORITHM,
+      iv
+    },
+    key,
+    dataArray
+  );
+  const decryptedString = decoder.decode(decryptedBuffer);
+  return decryptedString;
+}
+export {
+  createKey,
+  decodeKey,
+  decryptString,
+  encodeKey,
+  encryptString,
+  importKey
+};

package/dist/core/errors/errors-data.d.ts

@@ -1151,6 +1151,16 @@ export declare const RewriteWithBodyUsed: {
     title: string;
     message: string;
 };
+/**
+ * @docs
+ * @description
+ * An unknown error occurred while reading or writing files to disk. It can be caused by many things, eg. missing permissions or a file not existing we attempt to read.
+ */
+export declare const UnknownFilesystemError: {
+    name: string;
+    title: string;
+    hint: string;
+};
 /**
  * @docs
  * @kind heading
@@ -1320,6 +1330,17 @@ export declare const UnknownContentCollectionError: {
     name: string;
     title: string;
 };
+/**
+ * @docs
+ * @description
+ * The `getDataEntryById` and `getEntryBySlug` functions are deprecated and cannot be used with content layer collections. Use the `getEntry` function instead.
+ */
+export declare const GetEntryDeprecationError: {
+    name: string;
+    title: string;
+    message: (collection: string, method: string) => string;
+    hint: string;
+};
 /**
  * @docs
  * @message

package/dist/core/errors/errors-data.js

@@ -419,6 +419,11 @@ const RewriteWithBodyUsed = {
   title: "Cannot use Astro.rewrite after the request body has been read",
   message: "Astro.rewrite() cannot be used if the request body has already been read. If you need to read the body, first clone the request."
 };
+const UnknownFilesystemError = {
+  name: "UnknownFilesystemError",
+  title: "An unknown error occurred while reading or writing files to disk.",
+  hint: "It can be caused by many things, eg. missing permissions or a file not existing we attempt to read. Check the error cause for more details."
+};
 const UnknownCSSError = {
   name: "UnknownCSSError",
   title: "Unknown CSS Error."
@@ -476,6 +481,12 @@ const UnknownContentCollectionError = {
   name: "UnknownContentCollectionError",
   title: "Unknown Content Collection Error."
 };
+const GetEntryDeprecationError = {
+  name: "GetEntryDeprecationError",
+  title: "Invalid use of `getDataEntryById` or `getEntryBySlug` function.",
+  message: (collection, method) => `The \`${method}\` function is deprecated and cannot be used to query the "${collection}" collection. Use \`getEntry\` instead.`,
+  hint: "Use the `getEntry` or `getCollection` functions to query content layer collections."
+};
 const InvalidContentEntryFrontmatterError = {
   name: "InvalidContentEntryFrontmatterError",
   title: "Content entry frontmatter does not match schema.",
@@ -602,6 +613,7 @@ export {
   FailedToFindPageMapSSR,
   FailedToLoadModuleSSR,
   GenerateContentTypesError,
+  GetEntryDeprecationError,
   GetStaticPathsExpectedParams,
   GetStaticPathsInvalidRouteParam,
   GetStaticPathsRemovedRSSHelper,
@@ -664,6 +676,7 @@ export {
   UnknownConfigError,
   UnknownContentCollectionError,
   UnknownError,
+  UnknownFilesystemError,
   UnknownMarkdownError,
   UnknownViteError,
   UnsupportedConfigTransformError,

package/dist/core/index.js

@@ -3,7 +3,7 @@ import { default as _sync } from "./sync/index.js";
 import { default as default2 } from "./dev/index.js";
 import { default as default3 } from "./preview/index.js";
 const build = (inlineConfig) => _build(inlineConfig);
-const sync = (inlineConfig) => _sync({ inlineConfig });
+const sync = (inlineConfig) => _sync(inlineConfig);
 export {
   build,
   default2 as dev,

package/dist/core/messages.js

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

package/dist/core/render-context.js

@@ -279,6 +279,7 @@ class RenderContext {
       styles,
       actionResult,
       serverIslandNameMap: manifest.serverIslandNameMap ?? /* @__PURE__ */ new Map(),
+      key: manifest.key,
       trailingSlash: manifest.trailingSlash,
       _metadata: {
         hasHydrationScript: false,

package/dist/core/server-islands/endpoint.js

@@ -3,6 +3,7 @@ import {
   renderTemplate
 } from "../../runtime/server/index.js";
 import { createSlotValueFromString } from "../../runtime/server/render/slot.js";
+import { decryptString } from "../encryption.js";
 import { getPattern } from "../routing/manifest/pattern.js";
 const SERVER_ISLAND_ROUTE = "/_server-islands/[name]";
 const SERVER_ISLAND_COMPONENT = "_server-islands.astro";
@@ -51,7 +52,10 @@ function createEndpoint(manifest) {
         statusText: "Not found"
       });
     }
-    const props = data.props;
+    const key = await manifest.key;
+    const encryptedProps = data.encryptedProps;
+    const propString = await decryptString(key, encryptedProps);
+    const props = JSON.parse(propString);
     const componentModule = await imp();
     const Component = componentModule[data.componentExport];
     const slots = {};

package/dist/core/sync/constants.d.ts

@@ -0,0 +1 @@
+export declare const REFERENCE_FILE = "./types.d.ts";

package/dist/core/sync/constants.js

@@ -0,0 +1,4 @@
+const REFERENCE_FILE = "./types.d.ts";
+export {
+  REFERENCE_FILE
+};

package/dist/core/sync/index.d.ts

@@ -1,22 +1,30 @@
 import fsMod from 'node:fs';
-import type { AstroInlineConfig, AstroSettings } from '../../@types/astro.js';
+import type { AstroConfig, AstroInlineConfig, AstroSettings } from '../../@types/astro.js';
 import type { Logger } from '../logger/core.js';
 export type SyncOptions = {
     logger: Logger;
     settings: AstroSettings;
+    force?: boolean;
     skip?: {
         content?: boolean;
     };
 };
-export default function sync({ inlineConfig, fs, telemetry: _telemetry, }: {
-    inlineConfig: AstroInlineConfig;
+export default function sync(inlineConfig: AstroInlineConfig, { fs, telemetry: _telemetry }?: {
     fs?: typeof fsMod;
     telemetry?: boolean;
 }): Promise<void>;
+/**
+ * Clears the content layer and content collection cache, forcing a full rebuild.
+ */
+export declare function clearContentLayerCache({ astroConfig, logger, fs, }: {
+    astroConfig: AstroConfig;
+    logger: Logger;
+    fs?: typeof fsMod;
+}): Promise<void>;
 /**
  * Generates TypeScript types for all Astro modules. This sets up a `src/env.d.ts` file for type inferencing,
  * and defines the `astro:content` module for the Content Collections API.
  *
  * @experimental The JavaScript API is experimental
  */
-export declare function syncInternal({ logger, fs, settings, skip, }: SyncOptions): Promise<void>;
+export declare function syncInternal({ logger, fs, settings, skip, force, }: SyncOptions): Promise<void>;

package/dist/core/sync/index.js

@@ -1,15 +1,16 @@
-import fsMod from "node:fs";
+import fsMod, { existsSync } from "node:fs";
 import { performance } from "node:perf_hooks";
-import { fileURLToPath } from "node:url";
 import { dim } from "kleur/colors";
 import { createServer } from "vite";
-import { getPackage } from "../../cli/install-package.js";
+import { CONTENT_TYPES_FILE, DATA_STORE_FILE } from "../../content/consts.js";
+import { globalContentLayer } from "../../content/content-layer.js";
+import { DataStore, globalDataStore } from "../../content/data-store.js";
 import { createContentTypesGenerator } from "../../content/index.js";
-import { globalContentConfigObserver } from "../../content/utils.js";
+import { getContentPaths, globalContentConfigObserver } from "../../content/utils.js";
 import { syncAstroEnv } from "../../env/sync.js";
 import { telemetry } from "../../events/index.js";
 import { eventCliSession } from "../../events/session.js";
-import { runHookConfigSetup } from "../../integrations/hooks.js";
+import { runHookConfigDone, runHookConfigSetup } from "../../integrations/hooks.js";
 import { getTimeStat } from "../build/util.js";
 import { resolveConfig } from "../config/config.js";
 import { createNodeLogger } from "../config/logging.js";
@@ -25,12 +26,8 @@ import {
 } from "../errors/index.js";
 import { formatErrorMessage } from "../messages.js";
 import { ensureProcessNodeEnv } from "../util.js";
-import { setUpEnvTs } from "./setup-env-ts.js";
-async function sync({
-  inlineConfig,
-  fs,
-  telemetry: _telemetry = false
-}) {
+import { writeFiles } from "./write-files.js";
+async function sync(inlineConfig, { fs, telemetry: _telemetry = false } = {}) {
   ensureProcessNodeEnv("production");
   const logger = createNodeLogger(inlineConfig);
   const { astroConfig, userConfig } = await resolveConfig(inlineConfig ?? {}, "sync");
@@ -43,32 +40,65 @@ async function sync({
     settings,
     logger
   });
-  return await syncInternal({ settings, logger, fs });
+  await runHookConfigDone({ settings, logger });
+  return await syncInternal({ settings, logger, fs, force: inlineConfig.force });
+}
+async function clearContentLayerCache({
+  astroConfig,
+  logger,
+  fs = fsMod
+}) {
+  const dataStore = new URL(DATA_STORE_FILE, astroConfig.cacheDir);
+  if (fs.existsSync(dataStore)) {
+    logger.debug("content", "clearing data store");
+    await fs.promises.rm(dataStore, { force: true });
+    logger.warn("content", "data store cleared (force)");
+  }
 }
 async function syncInternal({
   logger,
   fs = fsMod,
   settings,
-  skip
+  skip,
+  force
 }) {
-  const cwd = fileURLToPath(settings.config.root);
+  if (force) {
+    await clearContentLayerCache({ astroConfig: settings.config, logger, fs });
+  }
   const timerStart = performance.now();
-  const dbPackage = await getPackage(
-    "@astrojs/db",
-    logger,
-    {
-      optional: true,
-      cwd
-    },
-    []
-  );
   try {
-    await dbPackage?.typegen?.(settings.config);
     if (!skip?.content) {
       await syncContentCollections(settings, { fs, logger });
+      settings.timer.start("Sync content layer");
+      let store;
+      try {
+        const dataStoreFile = new URL(DATA_STORE_FILE, settings.config.cacheDir);
+        if (existsSync(dataStoreFile)) {
+          store = await DataStore.fromFile(dataStoreFile);
+          globalDataStore.set(store);
+        }
+      } catch (err) {
+        logger.error("content", err.message);
+      }
+      if (!store) {
+        store = new DataStore();
+        globalDataStore.set(store);
+      }
+      const contentLayer = globalContentLayer.init({
+        settings,
+        logger,
+        store
+      });
+      await contentLayer.sync();
+      settings.timer.end("Sync content layer");
+    } else if (fs.existsSync(getContentPaths(settings.config, fs).contentDir.href)) {
+      settings.injectedTypes.push({
+        filename: CONTENT_TYPES_FILE,
+        content: ""
+      });
     }
     syncAstroEnv(settings, fs);
-    await setUpEnvTs({ settings, logger, fs });
+    await writeFiles(settings, fs, logger);
     logger.info("types", `Generated ${dim(getTimeStat(timerStart, performance.now()))}`);
   } catch (err) {
     const error = createSafeError(err);
@@ -137,6 +167,7 @@ async function syncContentCollections(settings, { logger, fs }) {
   }
 }
 export {
+  clearContentLayerCache,
   sync as default,
   syncInternal
 };

package/dist/core/sync/write-files.d.ts

@@ -0,0 +1,4 @@
+import type fsMod from 'node:fs';
+import type { AstroSettings } from '../../@types/astro.js';
+import type { Logger } from '../logger/core.js';
+export declare function writeFiles(settings: AstroSettings, fs: typeof fsMod, logger: Logger): Promise<void>;

package/dist/core/sync/write-files.js

@@ -0,0 +1,69 @@
+import { dirname, relative } from "node:path";
+import { fileURLToPath } from "node:url";
+import { bold } from "kleur/colors";
+import { normalizePath } from "vite";
+import { AstroError, AstroErrorData } from "../errors/index.js";
+import { REFERENCE_FILE } from "./constants.js";
+async function writeFiles(settings, fs, logger) {
+  try {
+    writeInjectedTypes(settings, fs);
+    await setUpEnvTs(settings, fs, logger);
+  } catch (e) {
+    throw new AstroError(AstroErrorData.UnknownFilesystemError, { cause: e });
+  }
+}
+function getTsReference(type, value) {
+  return `/// <reference ${type}=${JSON.stringify(value)} />`;
+}
+const CLIENT_TYPES_REFERENCE = getTsReference("types", "astro/client");
+function writeInjectedTypes(settings, fs) {
+  const references = [];
+  for (const { filename, content } of settings.injectedTypes) {
+    const filepath = normalizePath(fileURLToPath(new URL(filename, settings.dotAstroDir)));
+    fs.mkdirSync(dirname(filepath), { recursive: true });
+    fs.writeFileSync(filepath, content, "utf-8");
+    references.push(normalizePath(relative(fileURLToPath(settings.dotAstroDir), filepath)));
+  }
+  const astroDtsContent = `${CLIENT_TYPES_REFERENCE}
+${references.map((reference) => getTsReference("path", reference)).join("\n")}`;
+  if (references.length === 0) {
+    fs.mkdirSync(settings.dotAstroDir, { recursive: true });
+  }
+  fs.writeFileSync(
+    normalizePath(fileURLToPath(new URL(REFERENCE_FILE, settings.dotAstroDir))),
+    astroDtsContent,
+    "utf-8"
+  );
+}
+async function setUpEnvTs(settings, fs, logger) {
+  const envTsPath = normalizePath(fileURLToPath(new URL("env.d.ts", settings.config.srcDir)));
+  const envTsPathRelativetoRoot = normalizePath(
+    relative(fileURLToPath(settings.config.root), envTsPath)
+  );
+  const relativePath = normalizePath(
+    relative(
+      fileURLToPath(settings.config.srcDir),
+      fileURLToPath(new URL(REFERENCE_FILE, settings.dotAstroDir))
+    )
+  );
+  const expectedTypeReference = getTsReference("path", relativePath);
+  if (fs.existsSync(envTsPath)) {
+    const initialEnvContents = await fs.promises.readFile(envTsPath, "utf-8");
+    let typesEnvContents = initialEnvContents;
+    if (!typesEnvContents.includes(expectedTypeReference)) {
+      typesEnvContents = `${expectedTypeReference}
+${typesEnvContents}`;
+    }
+    if (initialEnvContents !== typesEnvContents) {
+      logger.info("types", `Updated ${bold(envTsPathRelativetoRoot)} type declarations.`);
+      await fs.promises.writeFile(envTsPath, typesEnvContents, "utf-8");
+    }
+  } else {
+    await fs.promises.mkdir(settings.config.srcDir, { recursive: true });
+    await fs.promises.writeFile(envTsPath, expectedTypeReference, "utf-8");
+    logger.info("types", `Added ${bold(envTsPathRelativetoRoot)} type declarations`);
+  }
+}
+export {
+  writeFiles
+};