astro 1.3.0 → 1.4.0

package/dist/@types/astro.d.ts

@@ -9,6 +9,7 @@ import type { z } from 'zod';
 import type { SerializedSSRManifest } from '../core/app/types';
 import type { PageBuildData } from '../core/build/types';
 import type { AstroConfigSchema } from '../core/config';
+import type { AstroCookies } from '../core/cookies';
 import type { ViteConfigWithSSR } from '../core/create-vite';
 import type { AstroComponentFactory, Metadata } from '../runtime/server';
 export type { MarkdownHeading, MarkdownMetadata, MarkdownRenderingResult, RehypePlugins, RemarkPlugins, ShikiConfig, } from '@astrojs/markdown-remark';
@@ -92,6 +93,10 @@ export interface AstroGlobal extends AstroGlobalPartial {
      *
      * [Astro reference](https://docs.astro.build/en/reference/api-reference/#url)
      */
+    /**
+     * Utility for getting and setting cookies values.
+     */
+    cookies: AstroCookies;
     url: URL;
     /** Parameters passed to a dynamic page generated using [getStaticPaths](https://docs.astro.build/en/reference/api-reference/#getstaticpaths)
      *
@@ -974,6 +979,7 @@ export interface AstroAdapter {
 }
 declare type Body = string;
 export interface APIContext {
+    cookies: AstroCookies;
     params: Params;
     request: Request;
 }
@@ -1090,11 +1096,13 @@ export interface SSRMetadata {
     pathname: string;
     hasHydrationScript: boolean;
     hasDirectives: Set<string>;
+    hasRenderedHead: boolean;
 }
 export interface SSRResult {
     styles: Set<SSRElement>;
     scripts: Set<SSRElement>;
     links: Set<SSRElement>;
+    cookies: AstroCookies | undefined;
     createAstro(Astro: AstroGlobalPartial, props: Record<string, any>, slots: Record<string, any> | null): AstroGlobal;
     resolve: (s: string) => Promise<string>;
     response: ResponseInit;

package/dist/cli/index.js

@@ -187,7 +187,7 @@ async function runCommand(cmd, flags) {
       });
     }
     case "build": {
-      return await build(settings, { logging, telemetry });
+      return await build(settings, { ...flags, logging, telemetry });
     }
     case "check": {
       const ret = await check(settings);

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

@@ -11,4 +11,5 @@ export declare class App {
     constructor(manifest: Manifest, streaming?: boolean);
     match(request: Request, { matchNotFound }?: MatchOptions): RouteData | undefined;
     render(request: Request, routeData?: RouteData): Promise<Response>;
+    setCookieHeaders(response: Response): Generator<string, void, unknown>;
 }

package/dist/core/app/index.js

@@ -22,6 +22,7 @@ var __privateMethod = (obj, member, method) => {
 };
 var _manifest, _manifestData, _routeDataToRouteInfo, _routeCache, _encoder, _logging, _streaming, _renderPage, renderPage_fn, _callEndpoint, callEndpoint_fn;
 import mime from "mime";
+import { getSetCookiesFromResponse } from "../cookies/index.js";
 import { call as callEndpoint } from "../endpoint/index.js";
 import { consoleLogDestination } from "../logger/console.js";
 import { error } from "../logger/core.js";
@@ -111,6 +112,9 @@ class App {
       throw new Error(`Unsupported route type [${routeData.type}].`);
     }
   }
+  setCookieHeaders(response) {
+    return getSetCookiesFromResponse(response);
+  }
 }
 _manifest = new WeakMap();
 _manifestData = new WeakMap();

package/dist/core/build/index.js

@@ -64,6 +64,7 @@ class AstroBuilder {
       serverEntry: "entry.mjs"
     };
     await runHookBuildStart({ config: this.settings.config, buildConfig, logging: this.logging });
+    this.validateConfig();
     info(this.logging, "build", `output target: ${colors.green(this.settings.config.output)}`);
     if (this.settings.adapter) {
       info(this.logging, "build", `deploy adapter: ${colors.green(this.settings.adapter.name)}`);
@@ -129,6 +130,14 @@ class AstroBuilder {
       throw fixViteErrorMessage(_err);
     }
   }
+  validateConfig() {
+    const { config } = this.settings;
+    if (config.outDir.toString() === config.root.toString()) {
+      throw new Error(
+        `the outDir cannot be the root folder. Please build to a folder such as dist.`
+      );
+    }
+  }
   async printStats({
     logging,
     timeStart,

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

@@ -1,6 +1,7 @@
 import glob from "fast-glob";
 import fs from "fs";
 import { bgGreen, bgMagenta, black, dim } from "kleur/colors";
+import path from "path";
 import { fileURLToPath } from "url";
 import * as vite from "vite";
 import { createBuildInternals } from "../../core/build/internal.js";
@@ -82,8 +83,8 @@ async function ssrBuild(opts, internals, input) {
   const out = ssr ? opts.buildConfig.server : getOutDirWithinCwd(settings.config.outDir);
   const viteBuildConfig = {
     ...viteConfig,
+    mode: viteConfig.mode || "production",
     logLevel: opts.viteConfig.logLevel ?? "error",
-    mode: "production",
     build: {
       target: "esnext",
       ...viteConfig.build,
@@ -147,8 +148,8 @@ async function clientBuild(opts, internals, input) {
 ${bgGreen(black(" building client "))}`);
   const viteBuildConfig = {
     ...viteConfig,
+    mode: viteConfig.mode || "production",
     logLevel: "info",
-    mode: "production",
     build: {
       target: "esnext",
       ...viteConfig.build,
@@ -194,19 +195,38 @@ ${bgGreen(black(" building client "))}`);
 }
 async function cleanSsrOutput(opts) {
   const out = getOutDirWithinCwd(opts.settings.config.outDir);
+  const files = await glob("**/*.mjs", {
+    cwd: fileURLToPath(out)
+  });
+  if (files.length) {
+    await Promise.all(
+      files.map(async (filename) => {
+        const url = new URL(filename, out);
+        await fs.promises.rm(url);
+      })
+    );
+    const directories = /* @__PURE__ */ new Set();
+    files.forEach((i) => {
+      const splitFilePath = i.split(path.sep);
+      if (splitFilePath.length > 1) {
+        directories.add(splitFilePath[0]);
+      }
+    });
+    await Promise.all(
+      Array.from(directories).map(async (filename) => {
+        const url = new URL(filename, out);
+        const folder = await fs.promises.readdir(url);
+        if (!folder.length) {
+          await fs.promises.rmdir(url, { recursive: true });
+        }
+      })
+    );
+  }
   if (out.toString() !== opts.settings.config.outDir.toString()) {
+    copyFiles(out, opts.settings.config.outDir);
     await fs.promises.rm(out, { recursive: true });
     return;
   }
-  const files = await glob("**/*.mjs", {
-    cwd: fileURLToPath(out)
-  });
-  await Promise.all(
-    files.map(async (filename) => {
-      const url = new URL(filename, out);
-      await fs.promises.rm(url);
-    })
-  );
 }
 async function copyFiles(fromFolder, toFolder) {
   const files = await glob("**/*", {

package/dist/core/config/config.js

@@ -182,7 +182,10 @@ async function tryLoadConfig(configOptions, flags, root) {
       server: { middlewareMode: true, hmr: false },
       optimizeDeps: { entries: [] },
       clearScreen: false,
-      appType: "custom"
+      appType: "custom",
+      ssr: {
+        external: ["@astrojs/mdx", "@astrojs/react"]
+      }
     });
     try {
       const mod = await viteServer.ssrLoadModule(configPath);

package/dist/core/cookies/cookies.d.ts

@@ -0,0 +1,75 @@
+interface AstroCookieSetOptions {
+    domain?: string;
+    expires?: Date;
+    httpOnly?: boolean;
+    maxAge?: number;
+    path?: string;
+    sameSite?: boolean | 'lax' | 'none' | 'strict';
+    secure?: boolean;
+}
+interface AstroCookieDeleteOptions {
+    path?: string;
+}
+interface AstroCookieInterface {
+    value: string | undefined;
+    json(): Record<string, any>;
+    number(): number;
+    boolean(): boolean;
+}
+interface AstroCookiesInterface {
+    get(key: string): AstroCookieInterface;
+    has(key: string): boolean;
+    set(key: string, value: string | Record<string, any>, options?: AstroCookieSetOptions): void;
+    delete(key: string, options?: AstroCookieDeleteOptions): void;
+}
+declare class AstroCookie implements AstroCookieInterface {
+    value: string | undefined;
+    constructor(value: string | undefined);
+    json(): any;
+    number(): number;
+    boolean(): boolean;
+}
+declare class AstroCookies implements AstroCookiesInterface {
+    #private;
+    constructor(request: Request);
+    /**
+     * Astro.cookies.delete(key) is used to delete a cookie. Using this method will result
+     * in a Set-Cookie header added to the response.
+     * @param key The cookie to delete
+     * @param options Options related to this deletion, such as the path of the cookie.
+     */
+    delete(key: string, options?: AstroCookieDeleteOptions): void;
+    /**
+     * Astro.cookies.get(key) is used to get a cookie value. The cookie value is read from the
+     * request. If you have set a cookie via Astro.cookies.set(key, value), the value will be taken
+     * from that set call, overriding any values already part of the request.
+     * @param key The cookie to get.
+     * @returns An object containing the cookie value as well as convenience methods for converting its value.
+     */
+    get(key: string): AstroCookie;
+    /**
+     * Astro.cookies.has(key) returns a boolean indicating whether this cookie is either
+     * part of the initial request or set via Astro.cookies.set(key)
+     * @param key The cookie to check for.
+     * @returns
+     */
+    has(key: string): boolean;
+    /**
+     * Astro.cookies.set(key, value) is used to set a cookie's value. If provided
+     * an object it will be stringified via JSON.stringify(value). Additionally you
+     * can provide options customizing how this cookie will be set, such as setting httpOnly
+     * in order to prevent the cookie from being read in client-side JavaScript.
+     * @param key The name of the cookie to set.
+     * @param value A value, either a string or other primitive or an object.
+     * @param options Options for the cookie, such as the path and security settings.
+     */
+    set(key: string, value: string | Record<string, any>, options?: AstroCookieSetOptions): void;
+    /**
+     * Astro.cookies.header() returns an iterator for the cookies that have previously
+     * been set by either Astro.cookies.set() or Astro.cookies.delete().
+     * This method is primarily used by adapters to set the header on outgoing responses.
+     * @returns
+     */
+    headers(): Generator<string, void, unknown>;
+}
+export { AstroCookies };

package/dist/core/cookies/cookies.js

@@ -0,0 +1,154 @@
+var __accessCheck = (obj, member, msg) => {
+  if (!member.has(obj))
+    throw TypeError("Cannot " + msg);
+};
+var __privateGet = (obj, member, getter) => {
+  __accessCheck(obj, member, "read from private field");
+  return getter ? getter.call(obj) : member.get(obj);
+};
+var __privateAdd = (obj, member, value) => {
+  if (member.has(obj))
+    throw TypeError("Cannot add the same private member more than once");
+  member instanceof WeakSet ? member.add(obj) : member.set(obj, value);
+};
+var __privateSet = (obj, member, value, setter) => {
+  __accessCheck(obj, member, "write to private field");
+  setter ? setter.call(obj, value) : member.set(obj, value);
+  return value;
+};
+var __privateMethod = (obj, member, method) => {
+  __accessCheck(obj, member, "access private method");
+  return method;
+};
+var _request, _requestValues, _outgoing, _ensureParsed, ensureParsed_fn, _ensureOutgoingMap, ensureOutgoingMap_fn, _parse, parse_fn;
+import { parse, serialize } from "cookie";
+const DELETED_EXPIRATION = new Date(0);
+const DELETED_VALUE = "deleted";
+class AstroCookie {
+  constructor(value) {
+    this.value = value;
+  }
+  json() {
+    if (this.value === void 0) {
+      throw new Error(`Cannot convert undefined to an object.`);
+    }
+    return JSON.parse(this.value);
+  }
+  number() {
+    return Number(this.value);
+  }
+  boolean() {
+    if (this.value === "false")
+      return false;
+    if (this.value === "0")
+      return false;
+    return Boolean(this.value);
+  }
+}
+class AstroCookies {
+  constructor(request) {
+    __privateAdd(this, _ensureParsed);
+    __privateAdd(this, _ensureOutgoingMap);
+    __privateAdd(this, _parse);
+    __privateAdd(this, _request, void 0);
+    __privateAdd(this, _requestValues, void 0);
+    __privateAdd(this, _outgoing, void 0);
+    __privateSet(this, _request, request);
+    __privateSet(this, _requestValues, null);
+    __privateSet(this, _outgoing, null);
+  }
+  delete(key, options) {
+    const serializeOptions = {
+      expires: DELETED_EXPIRATION
+    };
+    if (options == null ? void 0 : options.path) {
+      serializeOptions.path = options.path;
+    }
+    __privateMethod(this, _ensureOutgoingMap, ensureOutgoingMap_fn).call(this).set(key, [
+      DELETED_VALUE,
+      serialize(key, DELETED_VALUE, serializeOptions),
+      false
+    ]);
+  }
+  get(key) {
+    if (__privateGet(this, _outgoing) !== null && __privateGet(this, _outgoing).has(key)) {
+      let [serializedValue, , isSetValue] = __privateGet(this, _outgoing).get(key);
+      if (isSetValue) {
+        return new AstroCookie(serializedValue);
+      } else {
+        return new AstroCookie(void 0);
+      }
+    }
+    const values = __privateMethod(this, _ensureParsed, ensureParsed_fn).call(this);
+    const value = values[key];
+    return new AstroCookie(value);
+  }
+  has(key) {
+    if (__privateGet(this, _outgoing) !== null && __privateGet(this, _outgoing).has(key)) {
+      let [, , isSetValue] = __privateGet(this, _outgoing).get(key);
+      return isSetValue;
+    }
+    const values = __privateMethod(this, _ensureParsed, ensureParsed_fn).call(this);
+    return !!values[key];
+  }
+  set(key, value, options) {
+    let serializedValue;
+    if (typeof value === "string") {
+      serializedValue = value;
+    } else {
+      let toStringValue = value.toString();
+      if (toStringValue === Object.prototype.toString.call(value)) {
+        serializedValue = JSON.stringify(value);
+      } else {
+        serializedValue = toStringValue;
+      }
+    }
+    const serializeOptions = {};
+    if (options) {
+      Object.assign(serializeOptions, options);
+    }
+    __privateMethod(this, _ensureOutgoingMap, ensureOutgoingMap_fn).call(this).set(key, [
+      serializedValue,
+      serialize(key, serializedValue, serializeOptions),
+      true
+    ]);
+  }
+  *headers() {
+    if (__privateGet(this, _outgoing) == null)
+      return;
+    for (const [, value] of __privateGet(this, _outgoing)) {
+      yield value[1];
+    }
+  }
+}
+_request = new WeakMap();
+_requestValues = new WeakMap();
+_outgoing = new WeakMap();
+_ensureParsed = new WeakSet();
+ensureParsed_fn = function() {
+  if (!__privateGet(this, _requestValues)) {
+    __privateMethod(this, _parse, parse_fn).call(this);
+  }
+  if (!__privateGet(this, _requestValues)) {
+    __privateSet(this, _requestValues, {});
+  }
+  return __privateGet(this, _requestValues);
+};
+_ensureOutgoingMap = new WeakSet();
+ensureOutgoingMap_fn = function() {
+  if (!__privateGet(this, _outgoing)) {
+    __privateSet(this, _outgoing, /* @__PURE__ */ new Map());
+  }
+  return __privateGet(this, _outgoing);
+};
+_parse = new WeakSet();
+parse_fn = function() {
+  const raw = __privateGet(this, _request).headers.get("cookie");
+  if (!raw) {
+    return;
+  }
+  __privateSet(this, _requestValues, parse(raw));
+};
+export {
+  AstroCookies
+};

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

@@ -0,0 +1,2 @@
+export { AstroCookies } from './cookies.js';
+export { attachToResponse, getSetCookiesFromResponse } from './response.js';

package/dist/core/cookies/index.js

@@ -0,0 +1,7 @@
+import { AstroCookies } from "./cookies.js";
+import { attachToResponse, getSetCookiesFromResponse } from "./response.js";
+export {
+  AstroCookies,
+  attachToResponse,
+  getSetCookiesFromResponse
+};

package/dist/core/cookies/response.d.ts

@@ -0,0 +1,3 @@
+import type { AstroCookies } from './cookies';
+export declare function attachToResponse(response: Response, cookies: AstroCookies): void;
+export declare function getSetCookiesFromResponse(response: Response): Generator<string, void, unknown>;

package/dist/core/cookies/response.js

@@ -0,0 +1,25 @@
+const astroCookiesSymbol = Symbol.for("astro.cookies");
+function attachToResponse(response, cookies) {
+  Reflect.set(response, astroCookiesSymbol, cookies);
+}
+function getFromResponse(response) {
+  let cookies = Reflect.get(response, astroCookiesSymbol);
+  if (cookies != null) {
+    return cookies;
+  } else {
+    return void 0;
+  }
+}
+function* getSetCookiesFromResponse(response) {
+  const cookies = getFromResponse(response);
+  if (!cookies) {
+    return;
+  }
+  for (const headerValue of cookies.headers()) {
+    yield headerValue;
+  }
+}
+export {
+  attachToResponse,
+  getSetCookiesFromResponse
+};

package/dist/core/create-vite.js

@@ -88,7 +88,8 @@ async function createVite(commandConfig, { settings, logging, mode }) {
       conditions: ["astro"]
     },
     ssr: {
-      noExternal: [...getSsrNoExternalDeps(settings.config.root), ...thirdPartyAstroPackages]
+      noExternal: [...getSsrNoExternalDeps(settings.config.root), ...thirdPartyAstroPackages],
+      external: mode === "dev" ? ["shiki"] : []
     }
   };
   let result = commonConfig;

package/dist/core/dev/index.js

@@ -46,7 +46,7 @@ async function dev(settings, options) {
       isRestart
     })
   );
-  const currentVersion = "1.3.0";
+  const currentVersion = "1.4.0";
   if (currentVersion.includes("-")) {
     warn(options.logging, null, msg.prerelease({ currentVersion }));
   }

package/dist/core/endpoint/index.js

@@ -1,5 +1,13 @@
 import { renderEndpoint } from "../../runtime/server/index.js";
+import { AstroCookies, attachToResponse } from "../cookies/index.js";
 import { getParamsAndProps, GetParamsAndPropsError } from "../render/core.js";
+function createAPIContext(request, params) {
+  return {
+    cookies: new AstroCookies(request),
+    request,
+    params
+  };
+}
 async function call(mod, opts) {
   const paramsAndPropsResp = await getParamsAndProps({ ...opts, mod });
   if (paramsAndPropsResp === GetParamsAndPropsError.NoMatchingStaticPath) {
@@ -8,8 +16,10 @@ async function call(mod, opts) {
     );
   }
   const [params] = paramsAndPropsResp;
-  const response = await renderEndpoint(mod, opts.request, params);
+  const context = createAPIContext(opts.request, params);
+  const response = await renderEndpoint(mod, context, opts.ssr);
   if (response instanceof Response) {
+    attachToResponse(response, context.cookies);
     return {
       type: "response",
       response

package/dist/core/messages.js

@@ -47,7 +47,7 @@ function serverStart({
   site,
   isRestart = false
 }) {
-  const version = "1.3.0";
+  const version = "1.4.0";
   const rootPath = site ? site.pathname : "/";
   const localPrefix = `${dim("\u2503")} Local    `;
   const networkPrefix = `${dim("\u2503")} Network  `;
@@ -97,12 +97,12 @@ function resolveServerUrls({
     const ipv4Networks = Object.values(os.networkInterfaces()).flatMap((networkInterface) => networkInterface ?? []).filter(
       (networkInterface) => (networkInterface == null ? void 0 : networkInterface.address) && (networkInterface == null ? void 0 : networkInterface.family) === (nodeVersion < 18 || nodeVersion >= 18.4 ? "IPv4" : 4)
     );
-    for (let { address: address2 } of ipv4Networks) {
-      if (address2.includes("127.0.0.1")) {
-        const displayAddress = address2.replace("127.0.0.1", localAddress);
+    for (let { address: ipv4Address } of ipv4Networks) {
+      if (ipv4Address.includes("127.0.0.1")) {
+        const displayAddress = ipv4Address.replace("127.0.0.1", localAddress);
         local = toDisplayUrl(displayAddress);
       } else {
-        network = toDisplayUrl(address2);
+        network = toDisplayUrl(ipv4Address);
       }
     }
   }
@@ -250,7 +250,7 @@ function printHelp({
     message.push(
       linebreak(),
       `  ${bgGreen(black(` ${commandName} `))} ${green(
-        `v${"1.3.0"}`
+        `v${"1.4.0"}`
       )} ${headline}`
     );
   }

package/dist/core/path.d.ts

@@ -1,3 +1,4 @@
+export declare function appendExtension(path: string, extension: string): string;
 export declare function appendForwardSlash(path: string): string;
 export declare function prependForwardSlash(path: string): string;
 export declare function removeTrailingForwardSlash(path: string): string;

package/dist/core/path.js

@@ -1,3 +1,6 @@
+function appendExtension(path, extension) {
+  return path + "." + extension;
+}
 function appendForwardSlash(path) {
   return path.endsWith("/") ? path : path + "/";
 }
@@ -41,6 +44,7 @@ function removeFileExtension(path) {
   return idx === -1 ? path : path.slice(0, idx);
 }
 export {
+  appendExtension,
   appendForwardSlash,
   isRelativePath,
   joinPaths,

package/dist/core/render/core.js

@@ -1,4 +1,5 @@
 import { Fragment, renderPage } from "../../runtime/server/index.js";
+import { attachToResponse } from "../cookies/index.js";
 import { getParams } from "../routing/params.js";
 import { createResult } from "./result.js";
 import { callGetStaticPaths, findPathItemByKey } from "./route-cache.js";
@@ -98,7 +99,11 @@ async function render(opts) {
       components: Object.assign((pageProps == null ? void 0 : pageProps.components) ?? {}, { Fragment })
     });
   }
-  return await renderPage(result, Component, pageProps, null, streaming);
+  const response = await renderPage(result, Component, pageProps, null, streaming);
+  if (result.cookies) {
+    attachToResponse(response, result.cookies);
+  }
+  return response;
 }
 export {
   GetParamsAndPropsError,

package/dist/core/render/result.js

@@ -19,6 +19,7 @@ var __privateSet = (obj, member, value, setter) => {
 var _cache, _result, _slots, _loggingOpts;
 import { bold } from "kleur/colors";
 import { renderSlot } from "../../runtime/server/index.js";
+import { AstroCookies } from "../cookies/index.js";
 import { warn } from "../logger/core.js";
 import { isScriptRequest } from "./script.js";
 import { isCSSRequest } from "./util.js";
@@ -123,10 +124,12 @@ function createResult(args) {
     enumerable: true,
     writable: false
   });
+  let cookies = void 0;
   const result = {
     styles: args.styles ?? /* @__PURE__ */ new Set(),
     scripts: args.scripts ?? /* @__PURE__ */ new Set(),
     links: args.links ?? /* @__PURE__ */ new Set(),
+    cookies,
     createAstro(astroGlobal, props, slots) {
       const astroSlots = new Slots(result, slots, args.logging);
       const Astro = {
@@ -145,6 +148,14 @@ function createResult(args) {
           }
           return Reflect.get(request, clientAddressSymbol);
         },
+        get cookies() {
+          if (cookies) {
+            return cookies;
+          }
+          cookies = new AstroCookies(request);
+          result.cookies = cookies;
+          return cookies;
+        },
         params,
         props,
         request,
@@ -229,6 +240,7 @@ const canonicalURL = new URL(Astro.url.pathname, Astro.site);
       renderers,
       pathname,
       hasHydrationScript: false,
+      hasRenderedHead: false,
       hasDirectives: /* @__PURE__ */ new Set()
     },
     response

package/dist/core/render/route-cache.js

@@ -62,14 +62,11 @@ class RouteCache {
 }
 function findPathItemByKey(staticPaths, params) {
   const paramsKey = stringifyParams(params);
-  let matchedStaticPath = staticPaths.keyed.get(paramsKey);
+  const matchedStaticPath = staticPaths.keyed.get(paramsKey);
   if (matchedStaticPath) {
     return matchedStaticPath;
   }
   debug("findPathItemByKey", `Unexpected cache miss looking for ${paramsKey}`);
-  matchedStaticPath = staticPaths.find(
-    ({ params: _params }) => JSON.stringify(_params) === paramsKey
-  );
 }
 export {
   RouteCache,

package/dist/core/routing/params.js

@@ -17,7 +17,7 @@ function stringifyParams(params) {
   const validatedParams = Object.entries(params).reduce((acc, next) => {
     validateGetStaticPathsParameter(next);
     const [key, value] = next;
-    acc[key] = `${value}`;
+    acc[key] = typeof value === "undefined" ? void 0 : `${value}`;
     return acc;
   }, {});
   return JSON.stringify(validatedParams, Object.keys(params).sort());

package/dist/core/util.js

@@ -5,7 +5,7 @@ import resolve from "resolve";
 import slash from "slash";
 import { fileURLToPath, pathToFileURL } from "url";
 import { prependForwardSlash, removeTrailingForwardSlash } from "./path.js";
-const ASTRO_VERSION = "1.3.0";
+const ASTRO_VERSION = "1.4.0";
 function isObject(value) {
   return typeof value === "object" && value != null;
 }
@@ -87,7 +87,7 @@ function resolveDependency(dep, projectRoot) {
   return pathToFileURL(resolved).toString();
 }
 function viteID(filePath) {
-  return slash(fileURLToPath(filePath) + filePath.search);
+  return slash(fileURLToPath(filePath) + filePath.search).replace(/\\/g, "/");
 }
 const VALID_ID_PREFIX = `/@id/`;
 function unwrapId(id) {

package/dist/runtime/server/astro-global.js

@@ -1,4 +1,4 @@
-const ASTRO_VERSION = "1.3.0";
+const ASTRO_VERSION = "1.4.0";
 function createDeprecatedFetchContentFn() {
   return () => {
     throw new Error("Deprecated: Astro.fetchContent() has been replaced with Astro.glob().");

package/dist/runtime/server/endpoint.d.ts

@@ -1,3 +1,3 @@
-import type { EndpointHandler, Params } from '../../@types/astro';
+import type { APIContext, EndpointHandler } from '../../@types/astro';
 /** Renders an endpoint request to completion, returning the body. */
-export declare function renderEndpoint(mod: EndpointHandler, request: Request, params: Params): Promise<Response | import("../../@types/astro").EndpointOutput>;
+export declare function renderEndpoint(mod: EndpointHandler, context: APIContext, ssr: boolean): Promise<Response | import("../../@types/astro").EndpointOutput>;

package/dist/runtime/server/endpoint.js

@@ -10,10 +10,15 @@ function getHandlerFromModule(mod, method) {
   }
   return void 0;
 }
-async function renderEndpoint(mod, request, params) {
+async function renderEndpoint(mod, context, ssr) {
   var _a;
+  const { request, params } = context;
   const chosenMethod = (_a = request.method) == null ? void 0 : _a.toLowerCase();
   const handler = getHandlerFromModule(mod, chosenMethod);
+  if (!ssr && ssr === false && chosenMethod && chosenMethod !== "get") {
+    console.warn(`
+${chosenMethod} requests are not available when building a static site. Update your config to output: 'server' to handle ${chosenMethod} requests.`);
+  }
   if (!handler || typeof handler !== "function") {
     let response = new Response(null, {
       status: 404,
@@ -33,10 +38,6 @@ export function get({ params, request }) {
 
 Update your code to remove this warning.`);
   }
-  const context = {
-    request,
-    params
-  };
   const proxy = new Proxy(context, {
     get(target, prop) {
       if (prop in target) {

package/dist/runtime/server/escape.d.ts

@@ -1,7 +1,6 @@
 import { escape } from 'html-escaper';
 export declare const escapeHTML: typeof escape;
 export declare class HTMLBytes extends Uint8Array {
-    get [Symbol.toStringTag](): string;
 }
 /**
  * A "blessed" extension of String that tells Astro that the string

package/dist/runtime/server/escape.js

@@ -1,10 +1,12 @@
 import { escape } from "html-escaper";
 const escapeHTML = escape;
 class HTMLBytes extends Uint8Array {
-  get [Symbol.toStringTag]() {
+}
+Object.defineProperty(HTMLBytes.prototype, Symbol.toStringTag, {
+  get() {
     return "HTMLBytes";
   }
-}
+});
 class HTMLString extends String {
   get [Symbol.toStringTag]() {
     return "HTMLString";

package/dist/runtime/server/hydration.js

@@ -59,7 +59,9 @@ function extractDirectives(inputProps) {
         }
       }
     } else if (key === "class:list") {
-      extracted.props[key.slice(0, -5)] = serializeListValue(value);
+      if (value) {
+        extracted.props[key.slice(0, -5)] = serializeListValue(value);
+      }
     } else {
       extracted.props[key] = value;
     }

package/dist/runtime/server/render/any.d.ts

@@ -1,2 +1 @@
 export declare function renderChild(child: any): AsyncIterable<any>;
-export declare function renderSlot(result: any, slotted: string, fallback?: any): Promise<string>;

package/dist/runtime/server/render/any.js

@@ -1,9 +1,14 @@
 import { escapeHTML, HTMLString, markHTMLString } from "../escape.js";
 import { AstroComponent, renderAstroComponent } from "./astro.js";
-import { stringifyChunk } from "./common.js";
+import { SlotString } from "./slot.js";
 async function* renderChild(child) {
   child = await child;
-  if (child instanceof HTMLString) {
+  if (child instanceof SlotString) {
+    if (child.instructions) {
+      yield* child.instructions;
+    }
+    yield child;
+  } else if (child instanceof HTMLString) {
     yield child;
   } else if (Array.isArray(child)) {
     for (const value of child) {
@@ -24,22 +29,6 @@ async function* renderChild(child) {
     yield child;
   }
 }
-async function renderSlot(result, slotted, fallback) {
-  if (slotted) {
-    let iterator = renderChild(slotted);
-    let content = "";
-    for await (const chunk of iterator) {
-      if (chunk.type === "directive") {
-        content += stringifyChunk(result, chunk);
-      } else {
-        content += chunk;
-      }
-    }
-    return markHTMLString(content);
-  }
-  return fallback;
-}
 export {
-  renderChild,
-  renderSlot
+  renderChild
 };

package/dist/runtime/server/render/component.js

@@ -2,15 +2,15 @@ import { markHTMLString } from "../escape.js";
 import { extractDirectives, generateHydrateScript } from "../hydration.js";
 import { serializeProps } from "../serialize.js";
 import { shorthash } from "../shorthash.js";
-import { renderSlot } from "./any.js";
 import {
   isAstroComponentFactory,
   renderAstroComponent,
   renderTemplate,
   renderToIterable
 } from "./astro.js";
-import { Fragment, Renderer } from "./common.js";
+import { Fragment, Renderer, stringifyChunk } from "./common.js";
 import { componentIsHTMLElement, renderHTMLElement } from "./dom.js";
+import { renderSlot, renderSlots } from "./slot.js";
 import { formatList, internalSpreadAttributes, renderElement, voidElementNames } from "./util.js";
 const rendererAliases = /* @__PURE__ */ new Map([["solid", "solid-js"]]);
 function guessRenderers(componentUrl) {
@@ -22,7 +22,7 @@ function guessRenderers(componentUrl) {
       return ["@astrojs/vue"];
     case "jsx":
     case "tsx":
-      return ["@astrojs/react", "@astrojs/preact"];
+      return ["@astrojs/react", "@astrojs/preact", "@astrojs/vue (jsx)"];
     default:
       return ["@astrojs/react", "@astrojs/preact", "@astrojs/vue", "@astrojs/svelte"];
   }
@@ -51,18 +51,10 @@ async function renderComponent(result, displayName, Component, _props, slots = {
       return markHTMLString(children2);
     }
     case "html": {
-      const children2 = {};
-      if (slots) {
-        await Promise.all(
-          Object.entries(slots).map(
-            ([key, value]) => renderSlot(result, value).then((output) => {
-              children2[key] = output;
-            })
-          )
-        );
-      }
+      const { slotInstructions: slotInstructions2, children: children2 } = await renderSlots(result, slots);
       const html2 = Component.render({ slots: children2 });
-      return markHTMLString(html2);
+      const hydrationHtml = slotInstructions2 ? slotInstructions2.map((instr) => stringifyChunk(result, instr)).join("") : "";
+      return markHTMLString(hydrationHtml + html2);
     }
     case "astro-factory": {
       async function* renderAstroComponentInline() {
@@ -97,16 +89,7 @@ There are no \`integrations\` set in your \`astro.config.mjs\` file.
 Did you mean to add ${formatList(probableRendererNames.map((r) => "`" + r + "`"))}?`;
     throw new Error(message);
   }
-  const children = {};
-  if (slots) {
-    await Promise.all(
-      Object.entries(slots).map(
-        ([key, value]) => renderSlot(result, value).then((output) => {
-          children[key] = output;
-        })
-      )
-    );
-  }
+  const { children, slotInstructions } = await renderSlots(result, slots);
   let renderer;
   if (metadata.hydrate !== "only") {
     if (Component && Component[Renderer]) {
@@ -259,6 +242,9 @@ ${serializeProps(
     island.props["await-children"] = "";
   }
   async function* renderAll() {
+    if (slotInstructions) {
+      yield* slotInstructions;
+    }
     yield { type: "directive", hydration, result };
     yield markHTMLString(renderElement("astro-island", island, false));
   }

package/dist/runtime/server/render/dom.js

@@ -1,5 +1,5 @@
 import { markHTMLString } from "../escape.js";
-import { renderSlot } from "./any.js";
+import { renderSlot } from "./slot.js";
 import { toAttributeString } from "./util.js";
 function componentIsHTMLElement(Component) {
   return typeof HTMLElement !== "undefined" && HTMLElement.isPrototypeOf(Component);

package/dist/runtime/server/render/head.js

@@ -5,9 +5,8 @@ const uniqueElements = (item, index, all) => {
   const children = item.children;
   return index === all.findIndex((i) => JSON.stringify(i.props) === props && i.children == children);
 };
-const alreadyHeadRenderedResults = /* @__PURE__ */ new WeakSet();
 function renderHead(result) {
-  alreadyHeadRenderedResults.add(result);
+  result._metadata.hasRenderedHead = true;
   const styles = Array.from(result.styles).filter(uniqueElements).map((style) => renderElement("style", style));
   result.styles.clear();
   const scripts = Array.from(result.scripts).filter(uniqueElements).map((script, i) => {
@@ -17,7 +16,7 @@ function renderHead(result) {
   return markHTMLString(links.join("\n") + styles.join("\n") + scripts.join("\n"));
 }
 async function* maybeRenderHead(result) {
-  if (alreadyHeadRenderedResults.has(result)) {
+  if (result._metadata.hasRenderedHead) {
     return;
   }
   yield renderHead(result);

package/dist/runtime/server/render/index.d.ts

@@ -1,11 +1,11 @@
 import { renderTemplate } from './astro.js';
-export { renderSlot } from './any.js';
 export { renderAstroComponent, renderTemplate, renderToString } from './astro.js';
 export { Fragment, Renderer, stringifyChunk } from './common.js';
 export { renderComponent } from './component.js';
 export { renderHTMLElement } from './dom.js';
 export { maybeRenderHead, renderHead } from './head.js';
 export { renderPage } from './page.js';
+export { renderSlot } from './slot.js';
 export type { RenderInstruction } from './types';
 export { addAttribute, defineScriptVars, voidElementNames } from './util.js';
 export interface AstroComponentFactory {

package/dist/runtime/server/render/index.js

@@ -1,10 +1,10 @@
-import { renderSlot } from "./any.js";
 import { renderAstroComponent, renderTemplate as renderTemplate2, renderToString } from "./astro.js";
 import { Fragment, Renderer, stringifyChunk } from "./common.js";
 import { renderComponent } from "./component.js";
 import { renderHTMLElement } from "./dom.js";
 import { maybeRenderHead, renderHead } from "./head.js";
 import { renderPage } from "./page.js";
+import { renderSlot } from "./slot.js";
 import { addAttribute, defineScriptVars, voidElementNames } from "./util.js";
 export {
   Fragment,

package/dist/runtime/server/render/page.js

@@ -88,9 +88,11 @@ async function renderPage(result, componentFactory, props, children, streaming)
     }
     let response = createResponse(body, { ...init, headers });
     return response;
-  } else {
-    return factoryReturnValue;
   }
+  if (!(factoryReturnValue instanceof Response)) {
+    throw new Error("Only instance of Response can be returned from an Astro file");
+  }
+  return factoryReturnValue;
 }
 export {
   renderPage

package/dist/runtime/server/render/slot.d.ts

@@ -0,0 +1,14 @@
+import type { SSRResult } from '../../../@types/astro.js';
+import type { RenderInstruction } from './types.js';
+import { HTMLString } from '../escape.js';
+export declare class SlotString extends HTMLString {
+    instructions: null | RenderInstruction[];
+    constructor(content: string, instructions: null | RenderInstruction[]);
+}
+export declare function renderSlot(_result: any, slotted: string, fallback?: any): Promise<string>;
+interface RenderSlotsResult {
+    slotInstructions: null | RenderInstruction[];
+    children: Record<string, string>;
+}
+export declare function renderSlots(result: SSRResult, slots?: any): Promise<RenderSlotsResult>;
+export {};

package/dist/runtime/server/render/slot.js

@@ -0,0 +1,52 @@
+import { HTMLString, markHTMLString } from "../escape.js";
+import { renderChild } from "./any.js";
+class SlotString extends HTMLString {
+  constructor(content, instructions) {
+    super(content);
+    this.instructions = instructions;
+  }
+}
+async function renderSlot(_result, slotted, fallback) {
+  if (slotted) {
+    let iterator = renderChild(slotted);
+    let content = "";
+    let instructions = null;
+    for await (const chunk of iterator) {
+      if (chunk.type === "directive") {
+        if (instructions === null) {
+          instructions = [];
+        }
+        instructions.push(chunk);
+      } else {
+        content += chunk;
+      }
+    }
+    return markHTMLString(new SlotString(content, instructions));
+  }
+  return fallback;
+}
+async function renderSlots(result, slots = {}) {
+  let slotInstructions = null;
+  let children = {};
+  if (slots) {
+    await Promise.all(
+      Object.entries(slots).map(
+        ([key, value]) => renderSlot(result, value).then((output) => {
+          if (output.instructions) {
+            if (slotInstructions === null) {
+              slotInstructions = [];
+            }
+            slotInstructions.push(...output.instructions);
+          }
+          children[key] = output;
+        })
+      )
+    );
+  }
+  return { slotInstructions, children };
+}
+export {
+  SlotString,
+  renderSlot,
+  renderSlots
+};

package/dist/runtime/server/render/util.js

@@ -5,7 +5,7 @@ const htmlBooleanAttributes = /^(allowfullscreen|async|autofocus|autoplay|contro
 const htmlEnumAttributes = /^(contenteditable|draggable|spellcheck|value)$/i;
 const svgEnumAttributes = /^(autoReverse|externalResourcesRequired|focusable|preserveAlpha)$/i;
 const STATIC_DIRECTIVES = /* @__PURE__ */ new Set(["set:html", "set:text"]);
-const toIdent = (k) => k.trim().replace(/(?:(?<!^)\b\w|\s+|[^\w]+)/g, (match, index) => {
+const toIdent = (k) => k.trim().replace(/(?:(?!^)\b\w|\s+|[^\w]+)/g, (match, index) => {
   if (/[^\w]|\s/.test(match))
     return "";
   return index === 0 ? match : match.toUpperCase();
@@ -16,7 +16,7 @@ const toStyleString = (obj) => Object.entries(obj).map(([k, v]) => `${kebab(k)}:
 function defineScriptVars(vars) {
   let output = "";
   for (const [key, value] of Object.entries(vars)) {
-    output += `let ${toIdent(key)} = ${JSON.stringify(value)};
+    output += `const ${toIdent(key)} = ${JSON.stringify(value)};
 `;
   }
   return markHTMLString(output);

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

@@ -3,9 +3,10 @@ import { invalidateCompilation, isCached } from "../core/compile/index.js";
 import { info } from "../core/logger/core.js";
 import * as msg from "../core/messages.js";
 import { isAstroScript } from "./query.js";
-const PKG_PREFIX = new URL("../../", import.meta.url);
+const PKG_PREFIX = fileURLToPath(new URL("../../", import.meta.url));
+const E2E_PREFIX = fileURLToPath(new URL("../../e2e", import.meta.url));
 const isPkgFile = (id) => {
-  return (id == null ? void 0 : id.startsWith(fileURLToPath(PKG_PREFIX))) || (id == null ? void 0 : id.startsWith(PKG_PREFIX.pathname));
+  return id && id.startsWith(PKG_PREFIX) && !id.startsWith(E2E_PREFIX);
 };
 async function handleHotUpdate(ctx, { config, logging, compile }) {
   let isStyleOnlyChange = false;

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

@@ -1,5 +1,6 @@
 import mime from "mime";
 import { Readable } from "stream";
+import { getSetCookiesFromResponse } from "../core/cookies/index.js";
 import { call as callEndpoint } from "../core/endpoint/dev/index.js";
 import {
   collectErrorMetadata,
@@ -34,6 +35,10 @@ async function writeWebResponse(res, webResponse) {
   } else {
     _headers = Object.fromEntries(headers.entries());
   }
+  const setCookieHeaders = Array.from(getSetCookiesFromResponse(webResponse));
+  if (setCookieHeaders.length) {
+    res.setHeader("Set-Cookie", setCookieHeaders);
+  }
   res.writeHead(status, _headers);
   if (body) {
     if (Symbol.for("astro.responseBody") in webResponse) {

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

@@ -1,6 +1,8 @@
 import { renderMarkdown } from "@astrojs/markdown-remark";
 import fs from "fs";
 import matter from "gray-matter";
+import { fileURLToPath } from "node:url";
+import { normalizePath } from "vite";
 import { collectErrorMetadata } from "../core/errors.js";
 import { warn } from "../core/logger/core.js";
 import { getFileInfo, safelyGetAstroData } from "../vite-plugin-utils/index.js";
@@ -12,6 +14,9 @@ function safeMatter(source, id) {
     throw collectErrorMetadata(e);
   }
 }
+const astroJsxRuntimeModulePath = normalizePath(
+  fileURLToPath(new URL("../jsx-runtime/index.js", import.meta.url))
+);
 function markdown({ settings, logging }) {
   return {
     enforce: "pre",
@@ -42,7 +47,7 @@ function markdown({ settings, logging }) {
           );
         }
         const code = escapeViteEnvReferences(`
-				import { Fragment, jsx as h } from 'astro/jsx-runtime';
+				import { Fragment, jsx as h } from '${astroJsxRuntimeModulePath}';
 				${layout ? `import Layout from ${JSON.stringify(layout)};` : ""}
 
 				const html = ${JSON.stringify(html)};

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

@@ -1,4 +1,4 @@
-import { appendForwardSlash } from "../core/path.js";
+import { appendExtension, appendForwardSlash } from "../core/path.js";
 function getFileInfo(id, config) {
   const sitePathname = appendForwardSlash(
     config.site ? new URL(config.base, config.site).pathname : config.base
@@ -8,6 +8,9 @@ function getFileInfo(id, config) {
   if (fileUrl && config.trailingSlash === "always") {
     fileUrl = appendForwardSlash(fileUrl);
   }
+  if (fileUrl && config.build.format === "file") {
+    fileUrl = appendExtension(fileUrl, "html");
+  }
   return { fileId, fileUrl };
 }
 function isValidAstroData(obj) {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "astro",
-  "version": "1.3.0",
+  "version": "1.4.0",
   "description": "Astro is a modern site builder with web best practices, performance, and DX front-of-mind.",
   "type": "module",
   "author": "withastro",
@@ -82,11 +82,11 @@
     "vendor"
   ],
   "dependencies": {
-    "@astrojs/compiler": "^0.24.0",
+    "@astrojs/compiler": "^0.25.0",
     "@astrojs/language-server": "^0.26.2",
-    "@astrojs/markdown-remark": "^1.1.2",
-    "@astrojs/telemetry": "^1.0.0",
-    "@astrojs/webapi": "^1.0.0",
+    "@astrojs/markdown-remark": "^1.1.3",
+    "@astrojs/telemetry": "^1.0.1",
+    "@astrojs/webapi": "^1.1.0",
     "@babel/core": "^7.18.2",
     "@babel/generator": "^7.18.2",
     "@babel/parser": "^7.18.4",
@@ -101,6 +101,7 @@
     "boxen": "^6.2.1",
     "ci-info": "^3.3.1",
     "common-ancestor-path": "^1.0.1",
+    "cookie": "^0.5.0",
     "debug": "^4.3.4",
     "diff": "^5.1.0",
     "eol": "^0.9.1",
@@ -148,25 +149,34 @@
     "@types/chai": "^4.3.1",
     "@types/common-ancestor-path": "^1.0.0",
     "@types/connect": "^3.4.35",
+    "@types/cookie": "^0.5.1",
     "@types/debug": "^4.1.7",
     "@types/diff": "^5.0.2",
     "@types/estree": "^0.0.51",
+    "@types/hast": "^2.3.4",
     "@types/mime": "^2.0.3",
     "@types/mocha": "^9.1.1",
     "@types/parse5": "^6.0.3",
     "@types/path-browserify": "^1.0.0",
     "@types/prettier": "^2.6.3",
+    "@types/prompts": "^2.0.14",
     "@types/resolve": "^1.20.2",
     "@types/rimraf": "^3.0.2",
     "@types/send": "^0.17.1",
     "@types/unist": "^2.0.6",
     "ast-types": "^0.14.2",
-    "astro-scripts": "0.0.7",
+    "astro-scripts": "0.0.8",
     "chai": "^4.3.6",
     "cheerio": "^1.0.0-rc.11",
     "mocha": "^9.2.2",
+    "node-fetch": "^3.2.5",
+    "rehype-autolink-headings": "^6.1.1",
+    "rehype-slug": "^5.0.1",
+    "rehype-toc": "^3.0.2",
+    "remark-code-titles": "^0.1.2",
     "sass": "^1.52.2",
-    "srcset-parse": "^1.1.0"
+    "srcset-parse": "^1.1.0",
+    "unified": "^10.1.2"
   },
   "engines": {
     "node": "^14.18.0 || >=16.12.0",