astro 1.3.1 → 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/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/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.1";
+  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, opts.ssr);
+  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.1";
+  const version = "1.4.0";
   const rootPath = site ? site.pathname : "/";
   const localPrefix = `${dim("\u2503")} Local    `;
   const networkPrefix = `${dim("\u2503")} Network  `;
@@ -250,7 +250,7 @@ function printHelp({
     message.push(
       linebreak(),
       `  ${bgGreen(black(` ${commandName} `))} ${green(
-        `v${"1.3.1"}`
+        `v${"1.4.0"}`
       )} ${headline}`
     );
   }

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/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.1";
+const ASTRO_VERSION = "1.4.0";
 function isObject(value) {
   return typeof value === "object" && value != null;
 }

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

@@ -1,4 +1,4 @@
-const ASTRO_VERSION = "1.3.1";
+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, ssr?: boolean): 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,8 +10,9 @@ function getHandlerFromModule(mod, method) {
   }
   return void 0;
 }
-async function renderEndpoint(mod, request, params, ssr) {
+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") {
@@ -37,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/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/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/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/package.json

@@ -1,6 +1,6 @@
 {
   "name": "astro",
-  "version": "1.3.1",
+  "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,10 +82,10 @@
     "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/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",
@@ -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,14 +149,17 @@
     "@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",
@@ -165,8 +169,14 @@
     "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",