astro 1.4.7 → 1.5.1

package/dist/core/config/schema.d.ts

@@ -36,10 +36,19 @@ export declare const AstroConfigSchema: z.ZodObject<{
     }[], unknown>;
     build: z.ZodDefault<z.ZodOptional<z.ZodObject<{
         format: z.ZodDefault<z.ZodOptional<z.ZodUnion<[z.ZodLiteral<"file">, z.ZodLiteral<"directory">]>>>;
+        client: z.ZodEffects<z.ZodDefault<z.ZodOptional<z.ZodString>>, URL, string | undefined>;
+        server: z.ZodEffects<z.ZodDefault<z.ZodOptional<z.ZodString>>, URL, string | undefined>;
+        serverEntry: z.ZodDefault<z.ZodOptional<z.ZodString>>;
     }, "strip", z.ZodTypeAny, {
+        server: URL;
         format: "file" | "directory";
+        client: URL;
+        serverEntry: string;
     }, {
+        server?: string | undefined;
         format?: "file" | "directory" | undefined;
+        client?: string | undefined;
+        serverEntry?: string | undefined;
     }>>>;
     server: z.ZodEffects<z.ZodDefault<z.ZodOptional<z.ZodObject<{
         host: z.ZodDefault<z.ZodOptional<z.ZodUnion<[z.ZodString, z.ZodBoolean]>>>;
@@ -164,7 +173,10 @@ export declare const AstroConfigSchema: z.ZodObject<{
         hooks: {};
     }[];
     build: {
+        server: URL;
         format: "file" | "directory";
+        client: URL;
+        serverEntry: string;
     };
     style: {
         postcss: {
@@ -205,7 +217,10 @@ export declare const AstroConfigSchema: z.ZodObject<{
     } | undefined;
     integrations?: unknown;
     build?: {
+        server?: string | undefined;
         format?: "file" | "directory" | undefined;
+        client?: string | undefined;
+        serverEntry?: string | undefined;
     } | undefined;
     style?: {
         postcss?: {
@@ -218,7 +233,7 @@ export declare const AstroConfigSchema: z.ZodObject<{
         astroFlavoredMarkdown?: boolean | undefined;
     } | undefined;
 }>;
-export declare function createRelativeSchema(cmd: string, fileProtocolRoot: URL): z.ZodObject<z.extendShape<{
+export declare function createRelativeSchema(cmd: string, fileProtocolRoot: URL): z.ZodEffects<z.ZodObject<z.extendShape<{
     root: z.ZodEffects<z.ZodDefault<z.ZodOptional<z.ZodString>>, URL, string | undefined>;
     srcDir: z.ZodEffects<z.ZodDefault<z.ZodOptional<z.ZodString>>, URL, string | undefined>;
     publicDir: z.ZodEffects<z.ZodDefault<z.ZodOptional<z.ZodString>>, URL, string | undefined>;
@@ -252,10 +267,19 @@ export declare function createRelativeSchema(cmd: string, fileProtocolRoot: URL)
     }[], unknown>;
     build: z.ZodDefault<z.ZodOptional<z.ZodObject<{
         format: z.ZodDefault<z.ZodOptional<z.ZodUnion<[z.ZodLiteral<"file">, z.ZodLiteral<"directory">]>>>;
+        client: z.ZodEffects<z.ZodDefault<z.ZodOptional<z.ZodString>>, URL, string | undefined>;
+        server: z.ZodEffects<z.ZodDefault<z.ZodOptional<z.ZodString>>, URL, string | undefined>;
+        serverEntry: z.ZodDefault<z.ZodOptional<z.ZodString>>;
     }, "strip", z.ZodTypeAny, {
+        server: URL;
         format: "file" | "directory";
+        client: URL;
+        serverEntry: string;
     }, {
+        server?: string | undefined;
         format?: "file" | "directory" | undefined;
+        client?: string | undefined;
+        serverEntry?: string | undefined;
     }>>>;
     server: z.ZodEffects<z.ZodDefault<z.ZodOptional<z.ZodObject<{
         host: z.ZodDefault<z.ZodOptional<z.ZodUnion<[z.ZodString, z.ZodBoolean]>>>;
@@ -350,6 +374,22 @@ export declare function createRelativeSchema(cmd: string, fileProtocolRoot: URL)
     srcDir: z.ZodEffects<z.ZodDefault<z.ZodString>, URL, string | undefined>;
     publicDir: z.ZodEffects<z.ZodDefault<z.ZodString>, URL, string | undefined>;
     outDir: z.ZodEffects<z.ZodDefault<z.ZodString>, URL, string | undefined>;
+    build: z.ZodDefault<z.ZodOptional<z.ZodObject<{
+        format: z.ZodDefault<z.ZodOptional<z.ZodUnion<[z.ZodLiteral<"file">, z.ZodLiteral<"directory">]>>>;
+        client: z.ZodEffects<z.ZodDefault<z.ZodOptional<z.ZodString>>, URL, string | undefined>;
+        server: z.ZodEffects<z.ZodDefault<z.ZodOptional<z.ZodString>>, URL, string | undefined>;
+        serverEntry: z.ZodDefault<z.ZodOptional<z.ZodString>>;
+    }, "strip", z.ZodTypeAny, {
+        server: URL;
+        format: "file" | "directory";
+        client: URL;
+        serverEntry: string;
+    }, {
+        server?: string | undefined;
+        format?: "file" | "directory" | undefined;
+        client?: string | undefined;
+        serverEntry?: string | undefined;
+    }>>>;
     server: z.ZodEffects<z.ZodDefault<z.ZodOptional<z.ZodObject<{
         host: z.ZodDefault<z.ZodOptional<z.ZodUnion<[z.ZodString, z.ZodBoolean]>>>;
         port: z.ZodDefault<z.ZodOptional<z.ZodNumber>>;
@@ -425,7 +465,102 @@ export declare function createRelativeSchema(cmd: string, fileProtocolRoot: URL)
         hooks: {};
     }[];
     build: {
+        server: URL;
+        format: "file" | "directory";
+        client: URL;
+        serverEntry: string;
+    };
+    style: {
+        postcss: {
+            options?: any;
+            plugins: any[];
+        };
+    };
+    vite: ViteUserConfig;
+    legacy: {
+        astroFlavoredMarkdown: boolean;
+    };
+}, {
+    site?: string | undefined;
+    base?: string | undefined;
+    markdown?: {
+        drafts?: boolean | undefined;
+        syntaxHighlight?: false | "shiki" | "prism" | undefined;
+        shikiConfig?: {
+            langs?: ILanguageRegistration[] | undefined;
+            theme?: string | import("shiki").IShikiTheme | undefined;
+            wrap?: boolean | null | undefined;
+        } | undefined;
+        remarkPlugins?: (string | [string, any] | RemarkPlugin<any[]> | [RemarkPlugin<any[]>, any])[] | undefined;
+        rehypePlugins?: (string | [string, any] | RehypePlugin<any[]> | [RehypePlugin<any[]>, any])[] | undefined;
+        remarkRehype?: RemarkRehype | undefined;
+        extendDefaultPlugins?: boolean | undefined;
+    } | undefined;
+    root?: string | undefined;
+    srcDir?: string | undefined;
+    publicDir?: string | undefined;
+    outDir?: string | undefined;
+    trailingSlash?: "never" | "always" | "ignore" | undefined;
+    server?: unknown;
+    output?: "static" | "server" | undefined;
+    adapter?: {
+        hooks?: {} | undefined;
+        name: string;
+    } | undefined;
+    integrations?: unknown;
+    build?: {
+        server?: string | undefined;
+        format?: "file" | "directory" | undefined;
+        client?: string | undefined;
+        serverEntry?: string | undefined;
+    } | undefined;
+    style?: {
+        postcss?: unknown;
+    } | undefined;
+    vite?: ViteUserConfig | undefined;
+    legacy?: {
+        astroFlavoredMarkdown?: boolean | undefined;
+    } | undefined;
+}>, {
+    site?: string | undefined;
+    adapter?: {
+        name: string;
+        hooks: {};
+    } | undefined;
+    base: string;
+    markdown: {
+        drafts: boolean;
+        syntaxHighlight: false | "shiki" | "prism";
+        shikiConfig: {
+            langs: ILanguageRegistration[];
+            theme: string | import("shiki").IShikiTheme;
+            wrap: boolean | null;
+        };
+        remarkPlugins: (string | [string, any] | RemarkPlugin<any[]> | [RemarkPlugin<any[]>, any])[];
+        rehypePlugins: (string | [string, any] | RehypePlugin<any[]> | [RehypePlugin<any[]>, any])[];
+        remarkRehype: RemarkRehype;
+        extendDefaultPlugins: boolean;
+    };
+    root: URL;
+    srcDir: URL;
+    publicDir: URL;
+    outDir: URL;
+    trailingSlash: "never" | "always" | "ignore";
+    server: {
+        host: string | boolean;
+        port: number;
+        streaming: boolean;
+    };
+    output: "static" | "server";
+    integrations: {
+        name: string;
+        hooks: {};
+    }[];
+    build: {
+        server: URL;
         format: "file" | "directory";
+        client: URL;
+        serverEntry: string;
     };
     style: {
         postcss: {
@@ -466,7 +601,10 @@ export declare function createRelativeSchema(cmd: string, fileProtocolRoot: URL)
     } | undefined;
     integrations?: unknown;
     build?: {
+        server?: string | undefined;
         format?: "file" | "directory" | undefined;
+        client?: string | undefined;
+        serverEntry?: string | undefined;
     } | undefined;
     style?: {
         postcss?: unknown;

package/dist/core/config/schema.js

@@ -11,7 +11,12 @@ const ASTRO_CONFIG_DEFAULTS = {
   outDir: "./dist",
   base: "/",
   trailingSlash: "ignore",
-  build: { format: "directory" },
+  build: {
+    format: "directory",
+    client: "./dist/client/",
+    server: "./dist/server/",
+    serverEntry: "entry.mjs"
+  },
   server: {
     host: false,
     port: 3e3,
@@ -51,7 +56,10 @@ const AstroConfigSchema = z.object({
     z.array(z.object({ name: z.string(), hooks: z.object({}).passthrough().default({}) })).default(ASTRO_CONFIG_DEFAULTS.integrations)
   ),
   build: z.object({
-    format: z.union([z.literal("file"), z.literal("directory")]).optional().default(ASTRO_CONFIG_DEFAULTS.build.format)
+    format: z.union([z.literal("file"), z.literal("directory")]).optional().default(ASTRO_CONFIG_DEFAULTS.build.format),
+    client: z.string().optional().default(ASTRO_CONFIG_DEFAULTS.build.client).transform((val) => new URL(val)),
+    server: z.string().optional().default(ASTRO_CONFIG_DEFAULTS.build.server).transform((val) => new URL(val)),
+    serverEntry: z.string().optional().default(ASTRO_CONFIG_DEFAULTS.build.serverEntry)
   }).optional().default({}),
   server: z.preprocess(
     (val) => typeof val === "function" ? val({ command: "error" }) : val,
@@ -122,8 +130,25 @@ function createRelativeSchema(cmd, fileProtocolRoot) {
     srcDir: z.string().default(ASTRO_CONFIG_DEFAULTS.srcDir).transform((val) => new URL(appendForwardSlash(val), fileProtocolRoot)),
     publicDir: z.string().default(ASTRO_CONFIG_DEFAULTS.publicDir).transform((val) => new URL(appendForwardSlash(val), fileProtocolRoot)),
     outDir: z.string().default(ASTRO_CONFIG_DEFAULTS.outDir).transform((val) => new URL(appendForwardSlash(val), fileProtocolRoot)),
+    build: z.object({
+      format: z.union([z.literal("file"), z.literal("directory")]).optional().default(ASTRO_CONFIG_DEFAULTS.build.format),
+      client: z.string().optional().default(ASTRO_CONFIG_DEFAULTS.build.client).transform((val) => new URL(val, fileProtocolRoot)),
+      server: z.string().optional().default(ASTRO_CONFIG_DEFAULTS.build.server).transform((val) => new URL(val, fileProtocolRoot)),
+      serverEntry: z.string().optional().default(ASTRO_CONFIG_DEFAULTS.build.serverEntry)
+    }).optional().default({}),
     server: z.preprocess(
-      (val) => typeof val === "function" ? val({ command: cmd === "dev" ? "dev" : "preview" }) : val,
+      (val) => {
+        if (typeof val === "function") {
+          const result = val({ command: cmd === "dev" ? "dev" : "preview" });
+          if (val.port)
+            result.port = val.port;
+          if (val.host)
+            result.host = val.host;
+          return result;
+        } else {
+          return val;
+        }
+      },
       z.object({
         host: z.union([z.string(), z.boolean()]).optional().default(ASTRO_CONFIG_DEFAULTS.server.host),
         port: z.number().optional().default(ASTRO_CONFIG_DEFAULTS.server.port),
@@ -139,6 +164,14 @@ function createRelativeSchema(cmd, fileProtocolRoot) {
         }).optional().default(ASTRO_CONFIG_DEFAULTS.style.postcss)
       )
     }).optional().default({})
+  }).transform((config) => {
+    if (!config.build.server.toString().startsWith(config.outDir.toString()) && config.build.server.toString().endsWith("dist/server/")) {
+      config.build.server = new URL("./dist/server/", config.outDir);
+    }
+    if (!config.build.client.toString().startsWith(config.outDir.toString()) && config.build.client.toString().endsWith("dist/client/")) {
+      config.build.client = new URL("./dist/client/", config.outDir);
+    }
+    return config;
   });
   return AstroConfigRelativeSchema;
 }

package/dist/core/config/settings.d.ts

@@ -1,8 +1,2 @@
-import type { TsConfigJson } from 'tsconfig-resolver';
 import type { AstroConfig, AstroSettings } from '../../@types/astro';
-export interface CreateSettings {
-    config: AstroConfig;
-    tsConfig?: TsConfigJson;
-    tsConfigPath?: string;
-}
-export declare function createSettings({ config, tsConfig, tsConfigPath }: CreateSettings): AstroSettings;
+export declare function createSettings(config: AstroConfig, cwd?: string): AstroSettings;

package/dist/core/config/settings.js

@@ -1,14 +1,17 @@
 import jsxRenderer from "../../jsx/renderer.js";
-function createSettings({ config, tsConfig, tsConfigPath }) {
+import { loadTSConfig } from "./tsconfig.js";
+function createSettings(config, cwd) {
+  const tsconfig = loadTSConfig(cwd);
   return {
     config,
-    tsConfig,
-    tsConfigPath,
+    tsConfig: tsconfig == null ? void 0 : tsconfig.config,
+    tsConfigPath: tsconfig == null ? void 0 : tsconfig.path,
     adapter: void 0,
     injectedRoutes: [],
     pageExtensions: [".astro", ".md", ".html"],
     renderers: [jsxRenderer],
-    scripts: []
+    scripts: [],
+    watchFiles: (tsconfig == null ? void 0 : tsconfig.exists) ? [tsconfig.path, ...tsconfig.extendedPaths] : []
   };
 }
 export {

package/dist/core/config/tsconfig.d.ts

@@ -1,2 +1,11 @@
 import * as tsr from 'tsconfig-resolver';
-export declare function loadTSConfig(cwd: string | undefined): tsr.TsConfigResult | undefined;
+export declare const defaultTSConfig: tsr.TsConfigJson;
+export declare type frameworkWithTSSettings = 'vue' | 'react' | 'preact' | 'solid-js';
+export declare const presets: Map<frameworkWithTSSettings, tsr.TsConfigJson>;
+/**
+ * Load a tsconfig.json or jsconfig.json is the former is not found
+ * @param cwd Directory to start from
+ * @param resolve Determine if the function should go up directories like TypeScript would
+ */
+export declare function loadTSConfig(cwd: string | undefined, resolve?: boolean): tsr.TsConfigResult;
+export declare function updateTSConfigForFramework(target: tsr.TsConfigJson, framework: frameworkWithTSSettings): tsr.TsConfigJson;

package/dist/core/config/tsconfig.js

@@ -1,13 +1,78 @@
+import { deepmerge } from "deepmerge-ts";
+import { existsSync } from "fs";
+import { join } from "path";
 import * as tsr from "tsconfig-resolver";
-function loadTSConfig(cwd) {
-  for (const searchName of ["tsconfig.json", "jsconfig.json"]) {
-    const config = tsr.tsconfigResolverSync({ cwd, searchName });
-    if (config.exists) {
-      return config;
+const defaultTSConfig = { extends: "astro/tsconfigs/base" };
+const presets = /* @__PURE__ */ new Map([
+  [
+    "vue",
+    {
+      compilerOptions: {
+        jsx: "preserve"
+      }
     }
+  ],
+  [
+    "react",
+    {
+      compilerOptions: {
+        jsx: "react-jsx",
+        jsxImportSource: "react"
+      }
+    }
+  ],
+  [
+    "preact",
+    {
+      compilerOptions: {
+        jsx: "react-jsx",
+        jsxImportSource: "preact"
+      }
+    }
+  ],
+  [
+    "solid-js",
+    {
+      compilerOptions: {
+        jsx: "preserve",
+        jsxImportSource: "solid-js"
+      }
+    }
+  ]
+]);
+function loadTSConfig(cwd, resolve = true) {
+  cwd = cwd ?? process.cwd();
+  let config = tsr.tsconfigResolverSync({
+    cwd,
+    filePath: resolve ? void 0 : cwd,
+    ignoreExtends: !resolve
+  });
+  if (!resolve && config.reason === "invalid-config" && !existsSync(join(cwd, "tsconfig.json"))) {
+    config = { reason: "not-found", path: void 0, exists: false };
+  }
+  if (config.reason === "not-found") {
+    const jsconfig = tsr.tsconfigResolverSync({
+      cwd,
+      filePath: resolve ? void 0 : cwd,
+      searchName: "jsconfig.json",
+      ignoreExtends: !resolve
+    });
+    if (!resolve && jsconfig.reason === "invalid-config" && !existsSync(join(cwd, "jsconfig.json"))) {
+      return { reason: "not-found", path: void 0, exists: false };
+    }
+    return jsconfig;
+  }
+  return config;
+}
+function updateTSConfigForFramework(target, framework) {
+  if (!presets.has(framework)) {
+    return target;
   }
-  return void 0;
+  return deepmerge(target, presets.get(framework));
 }
 export {
-  loadTSConfig
+  defaultTSConfig,
+  loadTSConfig,
+  presets,
+  updateTSConfigForFramework
 };

package/dist/core/constants.d.ts

@@ -0,0 +1 @@
+export declare const ASTRO_VERSION: string;

package/dist/core/constants.js

@@ -0,0 +1,4 @@
+const ASTRO_VERSION = "1.5.1";
+export {
+  ASTRO_VERSION
+};

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

@@ -19,7 +19,7 @@ interface AstroCookieInterface {
 interface AstroCookiesInterface {
     get(key: string): AstroCookieInterface;
     has(key: string): boolean;
-    set(key: string, value: string | Record<string, any>, options?: AstroCookieSetOptions): void;
+    set(key: string, value: string | number | boolean | Record<string, any>, options?: AstroCookieSetOptions): void;
     delete(key: string, options?: AstroCookieDeleteOptions): void;
 }
 declare class AstroCookie implements AstroCookieInterface {

package/dist/core/dev/index.js

@@ -16,7 +16,12 @@ async function dev(settings, options) {
   const devStart = performance.now();
   applyPolyfill();
   await options.telemetry.record([]);
-  settings = await runHookConfigSetup({ settings, command: "dev", logging: options.logging });
+  settings = await runHookConfigSetup({
+    settings,
+    command: "dev",
+    logging: options.logging,
+    isRestart: options.isRestart
+  });
   const { host, port } = settings.config.server;
   const { isRestart = false } = options;
   const rendererClientEntries = settings.renderers.map((r) => r.clientEntrypoint).filter(Boolean);
@@ -49,7 +54,7 @@ async function dev(settings, options) {
       isRestart
     })
   );
-  const currentVersion = "1.4.7";
+  const currentVersion = "1.5.1";
   if (currentVersion.includes("-")) {
     warn(options.logging, null, msg.prerelease({ currentVersion }));
   }

package/dist/core/endpoint/dev/index.d.ts

@@ -1,9 +1,10 @@
 /// <reference types="node" />
 import type { SSROptions } from '../../render/dev';
-export declare function call(ssrOpts: SSROptions): Promise<{
+export declare function call(options: SSROptions): Promise<{
     type: "simple";
     body: string;
     encoding?: BufferEncoding | undefined;
+    cookies: import("../../cookies/cookies").AstroCookies;
 } | {
     type: "response";
     response: Response;

package/dist/core/endpoint/dev/index.js

@@ -1,11 +1,18 @@
-import { preload } from "../../render/dev/index.js";
+import { createRenderContext } from "../../render/index.js";
 import { call as callEndpoint } from "../index.js";
-async function call(ssrOpts) {
-  const [, mod] = await preload(ssrOpts);
-  return await callEndpoint(mod, {
-    ...ssrOpts,
-    ssr: ssrOpts.settings.config.output === "server"
+async function call(options) {
+  const {
+    env,
+    preload: [, mod]
+  } = options;
+  const endpointHandler = mod;
+  const ctx = createRenderContext({
+    request: options.request,
+    origin: options.origin,
+    pathname: options.pathname,
+    route: options.route
   });
+  return await callEndpoint(endpointHandler, env, ctx);
 }
 export {
   call

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

@@ -1,14 +1,15 @@
 /// <reference types="node" />
 import type { EndpointHandler } from '../../@types/astro';
-import type { RenderOptions } from '../render/core';
-export declare type EndpointOptions = Pick<RenderOptions, 'logging' | 'origin' | 'request' | 'route' | 'routeCache' | 'pathname' | 'route' | 'site' | 'ssr' | 'status'>;
+import type { Environment, RenderContext } from '../render/index';
+import { AstroCookies } from '../cookies/index.js';
 declare type EndpointCallResult = {
     type: 'simple';
     body: string;
     encoding?: BufferEncoding;
+    cookies: AstroCookies;
 } | {
     type: 'response';
     response: Response;
 };
-export declare function call(mod: EndpointHandler, opts: EndpointOptions): Promise<EndpointCallResult>;
+export declare function call(mod: EndpointHandler, env: Environment, ctx: RenderContext): Promise<EndpointCallResult>;
 export {};

package/dist/core/endpoint/index.js

@@ -1,23 +1,70 @@
 import { renderEndpoint } from "../../runtime/server/index.js";
+import { ASTRO_VERSION } from "../constants.js";
 import { AstroCookies, attachToResponse } from "../cookies/index.js";
 import { getParamsAndProps, GetParamsAndPropsError } from "../render/core.js";
-function createAPIContext(request, params) {
+const clientAddressSymbol = Symbol.for("astro.clientAddress");
+function createAPIContext({
+  request,
+  params,
+  site,
+  props,
+  adapterName
+}) {
   return {
     cookies: new AstroCookies(request),
     request,
-    params
+    params,
+    site: site ? new URL(site) : void 0,
+    generator: `Astro v${ASTRO_VERSION}`,
+    props,
+    redirect(path, status) {
+      return new Response(null, {
+        status: status || 302,
+        headers: {
+          Location: path
+        }
+      });
+    },
+    url: new URL(request.url),
+    get clientAddress() {
+      if (!(clientAddressSymbol in request)) {
+        if (adapterName) {
+          throw new Error(
+            `clientAddress is not available in the ${adapterName} adapter. File an issue with the adapter to add support.`
+          );
+        } else {
+          throw new Error(
+            `clientAddress is not available in your environment. Ensure that you are using an SSR adapter that supports this feature.`
+          );
+        }
+      }
+      return Reflect.get(request, clientAddressSymbol);
+    }
   };
 }
-async function call(mod, opts) {
-  const paramsAndPropsResp = await getParamsAndProps({ ...opts, mod });
+async function call(mod, env, ctx) {
+  const paramsAndPropsResp = await getParamsAndProps({
+    mod,
+    route: ctx.route,
+    routeCache: env.routeCache,
+    pathname: ctx.pathname,
+    logging: env.logging,
+    ssr: env.ssr
+  });
   if (paramsAndPropsResp === GetParamsAndPropsError.NoMatchingStaticPath) {
     throw new Error(
-      `[getStaticPath] route pattern matched, but no matching static path found. (${opts.pathname})`
+      `[getStaticPath] route pattern matched, but no matching static path found. (${ctx.pathname})`
     );
   }
-  const [params] = paramsAndPropsResp;
-  const context = createAPIContext(opts.request, params);
-  const response = await renderEndpoint(mod, context, opts.ssr);
+  const [params, props] = paramsAndPropsResp;
+  const context = createAPIContext({
+    request: ctx.request,
+    params,
+    props,
+    site: env.site,
+    adapterName: env.adapterName
+  });
+  const response = await renderEndpoint(mod, context, env.ssr);
   if (response instanceof Response) {
     attachToResponse(response, context.cookies);
     return {
@@ -28,7 +75,8 @@ async function call(mod, opts) {
   return {
     type: "simple",
     body: response.body,
-    encoding: response.encoding
+    encoding: response.encoding,
+    cookies: context.cookies
   };
 }
 export {

package/dist/core/messages.js

@@ -47,7 +47,7 @@ function serverStart({
   site,
   isRestart = false
 }) {
-  const version = "1.4.7";
+  const version = "1.5.1";
   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.4.7"}`
+        `v${"1.5.1"}`
       )} ${headline}`
     );
   }

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

@@ -1,19 +1,10 @@
-/// <reference types="node" />
 import type { AstroTelemetry } from '@astrojs/telemetry';
-import type { AstroSettings } from '../../@types/astro';
+import type { AstroSettings, PreviewServer } from '../../@types/astro';
 import type { LogOptions } from '../logger/core';
-import http from 'http';
 interface PreviewOptions {
     logging: LogOptions;
     telemetry: AstroTelemetry;
 }
-export interface PreviewServer {
-    host?: string;
-    port: number;
-    server: http.Server;
-    closed(): Promise<void>;
-    stop(): Promise<void>;
-}
 /** The primary dev action */
-export default function preview(settings: AstroSettings, { logging }: PreviewOptions): Promise<PreviewServer>;
+export default function preview(_settings: AstroSettings, { logging }: PreviewOptions): Promise<PreviewServer>;
 export {};