astro 7.0.0-alpha.0 → 7.0.0-alpha.2

package/dist/cli/dev/index.js

@@ -1,14 +1,31 @@
+import { isAgent } from "am-i-vibing";
 import colors from "piccolore";
 import devServer from "../../core/dev/index.js";
+import { pathToFileURL } from "node:url";
+import { checkExistingServer, removeLockFile, writeLockFile } from "../../core/dev/lockfile.js";
+import { resolveRoot } from "../../core/config/config.js";
 import { printHelp } from "../../core/messages/runtime.js";
-import { flagsToAstroInlineConfig } from "../flags.js";
+import { createLoggerFromFlags, flagsToAstroInlineConfig } from "../flags.js";
+function isRunByAgent() {
+  try {
+    return isAgent();
+  } catch {
+    return false;
+  }
+}
 async function dev({ flags }) {
   if (flags.help || flags.h) {
     printHelp({
       commandName: "astro dev",
-      usage: "[...flags]",
+      usage: "[command] [...flags]",
       tables: {
+        Commands: [
+          ["stop", "Stop a running background dev server."],
+          ["status", "Check if a dev server is running."],
+          ["logs [--follow]", "View logs from a background dev server."]
+        ],
         Flags: [
+          ["--background", "Start the dev server as a background process."],
           ["--mode", `Specify the mode of the project. Defaults to "development".`],
           ["--port", `Specify which port to run on. Defaults to 4321.`],
           ["--host", `Listen on all addresses, including LAN and public addresses.`],
@@ -28,8 +45,70 @@ async function dev({ flags }) {
     });
     return;
   }
+  const agentDetected = !process.env.ASTRO_DEV_BACKGROUND && isRunByAgent();
+  if (agentDetected) {
+    flags.experimentalJson = true;
+  }
+  const logger = createLoggerFromFlags(flags);
+  const subcommand = flags._[3]?.toString();
+  if (subcommand === "stop") {
+    const { stop } = await import("./stop.js");
+    await stop({ flags, logger });
+    return;
+  }
+  if (subcommand === "status") {
+    const { status } = await import("./status.js");
+    await status({ flags, logger });
+    return;
+  }
+  if (subcommand === "logs") {
+    const { logs } = await import("./logs.js");
+    await logs({ flags, logger });
+    return;
+  }
+  if (flags.background || agentDetected) {
+    const { background } = await import("./background.js");
+    await background({ flags, logger });
+    return;
+  }
+  if (subcommand) {
+    logger.error(
+      "SKIP_FORMAT",
+      `Unknown command: astro dev ${subcommand}
+
+Run \`astro dev --help\` to see available commands.`
+    );
+    process.exit(1);
+  }
+  const root = pathToFileURL(resolveRoot(flags.root) + "/");
+  const existingServer = checkExistingServer(root);
+  if (existingServer) {
+    const message = [
+      "Another astro dev server is already running.",
+      "",
+      `  URL:  ${existingServer.url}`,
+      `  PID:  ${existingServer.pid}`,
+      "",
+      `Run \`astro dev stop\` to stop it, or use \`astro dev --force\` to replace it.`
+    ].join("\n");
+    throw new Error(message);
+  }
   const inlineConfig = flagsToAstroInlineConfig(flags);
-  return await devServer(inlineConfig);
+  const server = await devServer(inlineConfig);
+  const serverUrl = new URL(server.resolvedUrls.local[0]).origin;
+  writeLockFile(root, {
+    pid: process.pid,
+    port: server.address.port,
+    url: serverUrl,
+    background: !!process.env.ASTRO_DEV_BACKGROUND,
+    startedAt: (/* @__PURE__ */ new Date()).toISOString()
+  });
+  const originalStop = server.stop.bind(server);
+  server.stop = async () => {
+    removeLockFile(root);
+    await originalStop();
+  };
+  return server;
 }
 export {
   dev

package/dist/cli/dev/logs.d.ts

@@ -0,0 +1,6 @@
+import type { AstroLogger } from '../../core/logger/core.js';
+import type { Flags } from '../flags.js';
+export declare function logs({ flags, logger, }: {
+    flags: Flags;
+    logger: AstroLogger;
+}): Promise<void>;

package/dist/cli/dev/logs.js

@@ -0,0 +1,72 @@
+import { readFileSync, existsSync, statSync, createReadStream, watch } from "node:fs";
+import { fileURLToPath, pathToFileURL } from "node:url";
+import { checkExistingServer, getLogFileURL, isProcessAlive } from "../../core/dev/lockfile.js";
+import { resolveRoot } from "../../core/config/config.js";
+async function logs({
+  flags,
+  logger
+}) {
+  const root = pathToFileURL(resolveRoot(flags.root) + "/");
+  const existing = checkExistingServer(root);
+  if (!existing) {
+    logger.error("SKIP_FORMAT", "No dev server is running.");
+    process.exit(1);
+  }
+  if (!existing.background) {
+    logger.error(
+      "SKIP_FORMAT",
+      "The running dev server was not started with `astro dev --background`. View logs in the terminal where it was started."
+    );
+    process.exit(1);
+  }
+  const logFileURL = getLogFileURL(root);
+  const logFilePath = fileURLToPath(logFileURL);
+  if (!existsSync(logFilePath)) {
+    logger.error("SKIP_FORMAT", "No log file found.");
+    process.exit(1);
+  }
+  const follow = flags.follow || flags.f;
+  if (!follow) {
+    const content = readFileSync(logFilePath, "utf-8");
+    process.stdout.write(content);
+    return;
+  }
+  let offset = statSync(logFilePath).size;
+  if (offset > 0) {
+    const content = readFileSync(logFilePath, "utf-8");
+    process.stdout.write(content);
+  }
+  const watcher = watch(logFilePath, () => {
+    const currentSize = statSync(logFilePath).size;
+    if (currentSize > offset) {
+      const stream = createReadStream(logFilePath, { start: offset, encoding: "utf-8" });
+      stream.on("data", (chunk) => process.stdout.write(chunk));
+      stream.on("end", () => {
+        offset = currentSize;
+      });
+    }
+  });
+  const aliveCheck = setInterval(() => {
+    if (!isProcessAlive(existing.pid)) {
+      const currentSize = statSync(logFilePath).size;
+      if (currentSize > offset) {
+        const remaining = readFileSync(logFilePath, { encoding: "utf-8" }).slice(offset);
+        process.stdout.write(remaining);
+      }
+      watcher.close();
+      clearInterval(aliveCheck);
+    }
+  }, 1e3);
+  const cleanup = () => {
+    watcher.close();
+    clearInterval(aliveCheck);
+    process.exit(0);
+  };
+  process.on("SIGINT", cleanup);
+  process.on("SIGTERM", cleanup);
+  await new Promise(() => {
+  });
+}
+export {
+  logs
+};

package/dist/cli/dev/status.d.ts

@@ -0,0 +1,15 @@
+import type { AstroLogger } from '../../core/logger/core.js';
+import type { Flags } from '../flags.js';
+export interface StatusResult {
+    running: boolean;
+    pid?: number;
+    url?: string;
+    port?: number;
+    background?: boolean;
+    uptime?: number;
+}
+export declare function formatStatusOutput(result: StatusResult): string;
+export declare function status({ flags, logger, }: {
+    flags: Flags;
+    logger: AstroLogger;
+}): Promise<void>;

package/dist/cli/dev/status.js

@@ -0,0 +1,27 @@
+import { pathToFileURL } from "node:url";
+import { checkExistingServer } from "../../core/dev/lockfile.js";
+import { resolveRoot } from "../../core/config/config.js";
+function formatStatusOutput(result) {
+  return JSON.stringify(result);
+}
+async function status({
+  flags,
+  logger
+}) {
+  const root = pathToFileURL(resolveRoot(flags.root) + "/");
+  const existing = checkExistingServer(root);
+  if (!existing) {
+    logger.info("SKIP_FORMAT", "No dev server is running.");
+    return;
+  }
+  const startedAt = new Date(existing.startedAt).getTime();
+  const uptime = Math.floor((Date.now() - startedAt) / 1e3);
+  logger.info(
+    "SKIP_FORMAT",
+    `Dev server running at ${existing.url} (pid ${existing.pid}, uptime ${uptime}s${existing.background ? ", background" : ""})`
+  );
+}
+export {
+  formatStatusOutput,
+  status
+};

package/dist/cli/dev/stop.d.ts

@@ -0,0 +1,12 @@
+import type { AstroLogger } from '../../core/logger/core.js';
+import type { Flags } from '../flags.js';
+export interface StopResult {
+    stopped: boolean;
+    pid?: number;
+    reason?: string;
+}
+export declare function formatStopOutput(result: StopResult): string;
+export declare function stop({ flags, logger, }: {
+    flags: Flags;
+    logger: AstroLogger;
+}): Promise<void>;

package/dist/cli/dev/stop.js

@@ -0,0 +1,43 @@
+import { pathToFileURL } from "node:url";
+import {
+  checkExistingServer,
+  removeLockFile,
+  isProcessAlive,
+  GRACEFUL_SHUTDOWN_TIMEOUT
+} from "../../core/dev/lockfile.js";
+import { resolveRoot } from "../../core/config/config.js";
+function formatStopOutput(result) {
+  return JSON.stringify(result);
+}
+async function stop({
+  flags,
+  logger
+}) {
+  const root = pathToFileURL(resolveRoot(flags.root) + "/");
+  const existing = checkExistingServer(root);
+  if (!existing) {
+    logger.info("SKIP_FORMAT", "No dev server is running.");
+    return;
+  }
+  try {
+    process.kill(existing.pid, "SIGTERM");
+  } catch {
+  }
+  const deadline = Date.now() + GRACEFUL_SHUTDOWN_TIMEOUT;
+  while (Date.now() < deadline) {
+    if (!isProcessAlive(existing.pid)) break;
+    await new Promise((r) => setTimeout(r, 100));
+  }
+  if (isProcessAlive(existing.pid)) {
+    try {
+      process.kill(existing.pid, "SIGKILL");
+    } catch {
+    }
+  }
+  removeLockFile(root);
+  logger.info("SKIP_FORMAT", `Stopped dev server (pid ${existing.pid}).`);
+}
+export {
+  formatStopOutput,
+  stop
+};

package/dist/cli/infra/build-time-astro-version-provider.js

@@ -1,6 +1,6 @@
 class BuildTimeAstroVersionProvider {
   // Injected during the build through esbuild define
-  version = "7.0.0-alpha.0";
+  version = "7.0.0-alpha.2";
 }
 export {
   BuildTimeAstroVersionProvider

package/dist/container/index.js

@@ -3,9 +3,11 @@ import { getDefaultClientDirectives } from "../core/client-directive/index.js";
 import { ASTRO_CONFIG_DEFAULTS } from "../core/config/schemas/index.js";
 import { validateConfig } from "../core/config/validate.js";
 import { createKey } from "../core/encryption.js";
+import { FetchState } from "../core/fetch/fetch-state.js";
+import { AstroMiddleware } from "../core/middleware/astro-middleware.js";
 import { NOOP_MIDDLEWARE_FN } from "../core/middleware/noop-middleware.js";
+import { PagesHandler } from "../core/pages/handler.js";
 import { removeLeadingForwardSlash } from "../core/path.js";
-import { RenderContext } from "../core/render-context.js";
 import { getParts } from "../core/routing/parts.js";
 import { getPattern } from "../core/routing/pattern.js";
 import { validateSegment } from "../core/routing/segment.js";
@@ -69,6 +71,8 @@ function createManifest(manifest, renderers, middleware) {
 }
 class experimental_AstroContainer {
   #pipeline;
+  #astroMiddleware;
+  #pagesHandler;
   /**
    * Internally used to check if the container was created with a manifest.
    * @private
@@ -95,6 +99,8 @@ class experimental_AstroContainer {
         return specifier;
       }
     });
+    this.#astroMiddleware = new AstroMiddleware(this.#pipeline);
+    this.#pagesHandler = new PagesHandler(this.#pipeline);
   }
   async #containerResolve(specifier, astroConfig) {
     const found = this.#pipeline.manifest.entryModules[specifier];
@@ -285,23 +291,21 @@ class experimental_AstroContainer {
       params: options.params,
       type: routeType
     });
-    const renderContext = await RenderContext.create({
-      pipeline: this.#pipeline,
-      routeData,
-      status: 200,
-      request,
-      pathname: url.pathname,
-      locals: options?.locals ?? {},
-      partial: options?.partial ?? true,
-      clientAddress: ""
-    });
+    const state = new FetchState(this.#pipeline, request);
+    state.routeData = routeData;
+    state.pathname = url.pathname;
+    state.clientAddress = "";
+    state.partial = options?.partial ?? true;
+    state.componentInstance = componentInstance;
+    state.slots = slots ?? {};
     if (options.params) {
-      renderContext.params = options.params;
+      state.params = options.params;
     }
+    state.locals = options?.locals ?? {};
     if (options.props) {
-      renderContext.props = options.props;
+      state.initialProps = options.props;
     }
-    return renderContext.render(componentInstance, slots);
+    return this.#astroMiddleware.handle(state, this.#pagesHandler.handle.bind(this.#pagesHandler));
   }
   /**
    * It stores an Astro **page** route. The first argument, `route`, gets associated to the `component`.

package/dist/content/content-layer.js

@@ -1,8 +1,5 @@
 import { existsSync, promises as fs } from "node:fs";
-import {
-  createMarkdownProcessor,
-  parseFrontmatter
-} from "@astrojs/markdown-remark";
+import { parseFrontmatter } from "@astrojs/internal-helpers/frontmatter";
 import PQueue from "p-queue";
 import xxhash from "xxhash-wasm";
 import { AstroError, AstroErrorData } from "../core/errors/index.js";
@@ -28,7 +25,7 @@ class ContentLayer {
   #watcher;
   #lastConfigDigest;
   #unsubscribe;
-  #markdownProcessor;
+  #markdownRenderer;
   #generateDigest;
   #contentConfigObserver;
   #queue;
@@ -39,7 +36,6 @@ class ContentLayer {
     watcher,
     contentConfigObserver = globalContentConfigObserver
   }) {
-    watcher?.setMaxListeners(50);
     this.#logger = logger;
     this.#store = store;
     this.#settings = settings;
@@ -109,9 +105,18 @@ class ContentLayer {
     };
   }
   async #processMarkdown(content, options) {
-    this.#markdownProcessor ??= await createMarkdownProcessor(this.#settings.config.markdown);
+    if (!this.#markdownRenderer) {
+      const { markdown, image } = this.#settings.config;
+      this.#markdownRenderer = await markdown.processor.createRenderer({
+        image,
+        syntaxHighlight: markdown.syntaxHighlight,
+        shikiConfig: markdown.shikiConfig,
+        gfm: markdown.gfm,
+        smartypants: markdown.smartypants
+      });
+    }
     const { frontmatter, content: body } = parseFrontmatter(content);
-    const { code, metadata } = await this.#markdownProcessor.render(body, {
+    const { code, metadata } = await this.#markdownRenderer.render(body, {
       frontmatter,
       fileURL: options?.fileURL
     });
@@ -192,7 +197,7 @@ ${contentConfig.error.message}`
       logger.info("Content config changed");
       shouldClear = true;
     }
-    if (previousAstroVersion && previousAstroVersion !== "7.0.0-alpha.0") {
+    if (previousAstroVersion && previousAstroVersion !== "7.0.0-alpha.2") {
       logger.info("Astro version changed");
       shouldClear = true;
     }
@@ -200,8 +205,8 @@ ${contentConfig.error.message}`
       logger.info("Clearing content store");
       this.#store.clearAll();
     }
-    if ("7.0.0-alpha.0") {
-      this.#store.metaStore().set("astro-version", "7.0.0-alpha.0");
+    if ("7.0.0-alpha.2") {
+      this.#store.metaStore().set("astro-version", "7.0.0-alpha.2");
     }
     if (currentConfigDigest) {
       this.#store.metaStore().set("content-config-digest", currentConfigDigest);

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

@@ -1,4 +1,4 @@
-import type { MarkdownHeading } from '@astrojs/markdown-remark';
+import type { MarkdownHeading } from '@astrojs/internal-helpers/markdown';
 export interface RenderedContent {
     /** Rendered HTML string. If present then `render(entry)` will return a component that renders this HTML. */
     html: string;

package/dist/content/loaders/types.d.ts

@@ -64,7 +64,7 @@ export interface LoadCollectionContext<TCollectionFilter = unknown> {
     filter?: TCollectionFilter;
     collection: string;
 }
-export interface LiveLoader<TData extends Record<string, any> = Record<string, unknown>, TEntryFilter extends Record<string, any> | never = never, TCollectionFilter extends Record<string, any> | never = never, TError extends Error = Error> {
+export interface LiveLoader<TData extends Record<string, any> = Record<string, any>, TEntryFilter extends Record<string, any> | never = never, TCollectionFilter extends Record<string, any> | never = never, TError extends Error = Error> {
     /** Unique name of the loader, e.g. the npm package name */
     name: string;
     /** Load a single entry */

package/dist/content/runtime-assets.d.ts

@@ -2,10 +2,10 @@ import type { Rolldown } from 'vite';
 import * as z from 'zod/v4';
 export declare function createImage(pluginContext: Rolldown.PluginContext, shouldEmitFile: boolean, entryFilePath: string): () => z.ZodPipe<z.ZodString, z.ZodTransform<z.ZodNever | {
     ASTRO_ASSET: string;
-    format: import("../assets/types.js").ImageInputFormat;
-    src: string;
     width: number;
     height: number;
+    format: import("../assets/types.js").ImageInputFormat;
+    src: string;
     fsPath: string;
     orientation?: number | undefined;
 }, string>>;

package/dist/content/runtime.d.ts

@@ -1,4 +1,4 @@
-import type { MarkdownHeading } from '@astrojs/markdown-remark';
+import type { MarkdownHeading } from '@astrojs/internal-helpers/markdown';
 import * as z from 'zod/v4';
 import type * as zCore from 'zod/v4/core';
 import type { ImageMetadata } from '../assets/types.js';

package/dist/content/runtime.js

@@ -134,9 +134,10 @@ function createGetEntry({ liveCollections }) {
         return;
       }
       const { default: imageAssetMap } = await import("astro:asset-imports");
-      entry.data = updateImageReferencesInData(entry.data, entry.filePath, imageAssetMap);
+      const data = updateImageReferencesInData(entry.data, entry.filePath, imageAssetMap);
       const result = {
         ...entry,
+        data,
         collection
       };
       warnForPropertyAccess(
@@ -321,7 +322,9 @@ async function updateImageReferencesInBody(html, fileName) {
   const { getImage } = await import("virtual:astro:get-image");
   for (const [_full, imagePath] of html.matchAll(CONTENT_LAYER_IMAGE_REGEX)) {
     try {
-      const decodedImagePath = JSON.parse(imagePath.replaceAll(""", '"'));
+      const decodedImagePath = JSON.parse(
+        imagePath.replace(/&(?:#x22|quot);/g, '"').replace(/&(?:#x27|apos);/g, "'")
+      );
       let image;
       if (URL.canParse(decodedImagePath.src)) {
         image = await getImage(decodedImagePath);
@@ -350,11 +353,12 @@ async function updateImageReferencesInBody(html, fileName) {
       srcset: image.srcSet.attribute,
       // This attribute is used by the toolbar audit
       ...import.meta.env.DEV ? { "data-image-component": "true" } : {}
-    }).map(([key, value]) => value ? `${key}="${escape(value)}"` : "").join(" ");
+    }).filter(([, value]) => value != null).map(([key, value]) => value === "" ? `${key}=""` : `${key}="${escape(String(value))}"`).join(" ");
   });
 }
 function updateImageReferencesInData(data, fileName, imageAssetMap) {
-  return new Traverse(data).map(function(ctx, val) {
+  const copy = structuredClone(data);
+  new Traverse(copy).forEach(function(ctx, val) {
     if (typeof val === "string" && val.startsWith(IMAGE_IMPORT_PREFIX)) {
       const src = val.replace(IMAGE_IMPORT_PREFIX, "");
       const id = imageSrcToImportId(src, fileName);
@@ -375,6 +379,7 @@ function updateImageReferencesInData(data, fileName, imageAssetMap) {
       }
     }
   });
+  return copy;
 }
 async function renderEntry(entry) {
   if (!entry) {

package/dist/content/server-listeners.js

@@ -6,10 +6,6 @@ async function attachContentServerListeners({
   logger,
   settings
 }) {
-  const maxListeners = viteServer.watcher.getMaxListeners();
-  if (maxListeners !== 0 && maxListeners < 50) {
-    viteServer.watcher.setMaxListeners(50);
-  }
   const contentGenerator = await createContentTypesGenerator({
     fs,
     settings,

package/dist/content/types-generator.js

@@ -447,7 +447,11 @@ async function generateJSONSchema(fsMod, collectionConfig, collectionKey, collec
     zodSchemaForJson = await getContentLayerSchema(collectionConfig, collectionKey);
   }
   if (collectionConfig.type === CONTENT_LAYER_TYPE && collectionConfig.loader.name === "file-loader") {
-    zodSchemaForJson = z.object({}).catchall(zodSchemaForJson);
+    const itemSchema = zodSchemaForJson;
+    zodSchemaForJson = z.union([
+      z.array(itemSchema),
+      z.object({ $schema: z.string().optional() }).catchall(itemSchema)
+    ]);
   }
   if (zodSchemaForJson instanceof z.ZodObject) {
     const existingMeta = z.globalRegistry.get(zodSchemaForJson);

package/dist/content/utils.d.ts

@@ -124,7 +124,7 @@ export declare function getContentEntryIdAndSlug({ entry, contentDir, collection
     slug: string;
 };
 export declare function getEntryType(entryPath: string, paths: Pick<ContentPaths, 'config' | 'contentDir' | 'root'>, contentFileExts: string[], dataFileExts: string[]): 'content' | 'data' | 'config' | 'ignored';
-export declare function safeParseFrontmatter(source: string, id?: string): import("@astrojs/markdown-remark").ParseFrontmatterResult;
+export declare function safeParseFrontmatter(source: string, id?: string): import("@astrojs/internal-helpers/frontmatter").ParseFrontmatterResult;
 /**
  * The content config is loaded separately from other `src/` files.
  * This global observable lets dependent plugins (like the content flag plugin)

package/dist/content/utils.js

@@ -1,7 +1,7 @@
 import fsMod from "node:fs";
 import path from "node:path";
 import { fileURLToPath, pathToFileURL } from "node:url";
-import { parseFrontmatter } from "@astrojs/markdown-remark";
+import { parseFrontmatter } from "@astrojs/internal-helpers/frontmatter";
 import { slug as githubSlug } from "github-slugger";
 import colors from "piccolore";
 import xxhash from "xxhash-wasm";

package/dist/content/vite-plugin-content-assets.js

@@ -97,6 +97,7 @@ function astroContentAssetPropagationPlugin({
             stringifiedStyles = JSON.stringify(STYLES_PLACEHOLDER);
           }
           const code = `
+					"use astro:head-inject";
 					async function getMod() {
 						return import(${JSON.stringify(basePath)});
 					}

package/dist/content/vite-plugin-content-virtual-mod.js

@@ -1,7 +1,7 @@
 import nodeFs from "node:fs";
 import { fileURLToPath } from "node:url";
 import { dataToEsm } from "@rollup/pluginutils";
-import { normalizePath } from "vite";
+import { isRunnableDevEnvironment, normalizePath } from "vite";
 import { ASTRO_VITE_ENVIRONMENT_NAMES } from "../core/constants.js";
 import { AstroError, AstroErrorData } from "../core/errors/index.js";
 import { rootRelativePath } from "../core/viteUtils.js";
@@ -30,6 +30,14 @@ function invalidateDataStore(viteServer) {
     const timestamp = Date.now();
     environment.moduleGraph.invalidateModule(module, void 0, timestamp, true);
   }
+  if (isRunnableDevEnvironment(environment)) {
+    const runnerModule = environment.runner.evaluatedModules.getModuleById(
+      RESOLVED_DATA_STORE_VIRTUAL_ID
+    );
+    if (runnerModule) {
+      environment.runner.evaluatedModules.invalidateModule(runnerModule);
+    }
+  }
   environment.hot.send("astro:content-changed", {});
   viteServer.environments.client.hot.send({
     type: "full-reload",