eddev 2.0.0-beta.24 → 2.0.0-beta.241

package/dist/node/project/config.d.ts

@@ -1,130 +1,320 @@
 import { z } from "zod";
 import { Project } from "./project.js";
+export declare const EDCacheConfigSchema: z.ZodObject<{
+    wordpress: z.ZodDefault<z.ZodOptional<z.ZodObject<{
+        /** @deprecated */
+        strategy: z.ZodOptional<z.ZodEnum<["always", "ssr-always-fresh"]>>;
+        cacheHeaders: z.ZodDefault<z.ZodBoolean>;
+        transients: z.ZodDefault<z.ZodBoolean>;
+    }, "strip", z.ZodTypeAny, {
+        cacheHeaders: boolean;
+        transients: boolean;
+        strategy?: "always" | "ssr-always-fresh" | undefined;
+    }, {
+        strategy?: "always" | "ssr-always-fresh" | undefined;
+        cacheHeaders?: boolean | undefined;
+        transients?: boolean | undefined;
+    }>>>;
+    serverless: z.ZodDefault<z.ZodOptional<z.ZodObject<{
+        isr: z.ZodDefault<z.ZodOptional<z.ZodBoolean>>;
+        dataCache: z.ZodDefault<z.ZodEnum<["in-memory", "kv", "none"]>>;
+    }, "strip", z.ZodTypeAny, {
+        isr: boolean;
+        dataCache: "in-memory" | "kv" | "none";
+    }, {
+        isr?: boolean | undefined;
+        dataCache?: "in-memory" | "kv" | "none" | undefined;
+    }>>>;
+    pageDataTTL: z.ZodDefault<z.ZodNumber>;
+    appDataTTL: z.ZodDefault<z.ZodNumber>;
+    queryHooksTTL: z.ZodDefault<z.ZodNumber>;
+}, "strip", z.ZodTypeAny, {
+    wordpress: {
+        cacheHeaders: boolean;
+        transients: boolean;
+        strategy?: "always" | "ssr-always-fresh" | undefined;
+    };
+    serverless: {
+        isr: boolean;
+        dataCache: "in-memory" | "kv" | "none";
+    };
+    pageDataTTL: number;
+    appDataTTL: number;
+    queryHooksTTL: number;
+}, {
+    wordpress?: {
+        strategy?: "always" | "ssr-always-fresh" | undefined;
+        cacheHeaders?: boolean | undefined;
+        transients?: boolean | undefined;
+    } | undefined;
+    serverless?: {
+        isr?: boolean | undefined;
+        dataCache?: "in-memory" | "kv" | "none" | undefined;
+    } | undefined;
+    pageDataTTL?: number | undefined;
+    appDataTTL?: number | undefined;
+    queryHooksTTL?: number | undefined;
+}>;
 export declare const EDConfigSchema: z.ZodObject<{
     $schema: z.ZodOptional<z.ZodString>;
     version: z.ZodEffects<z.ZodEnum<["1", "2"]>, "2", "1" | "2">;
     legacyMetadata: z.ZodDefault<z.ZodOptional<z.ZodBoolean>>;
     legacyStitches: z.ZodDefault<z.ZodOptional<z.ZodBoolean>>;
-    tracking: z.ZodOptional<z.ZodObject<{
-        tagManagerID: z.ZodOptional<z.ZodString>;
-        ga: z.ZodOptional<z.ZodObject<{
-            trackingID: z.ZodOptional<z.ZodString>;
-            version: z.ZodEnum<["3", "4"]>;
-        }, "strip", z.ZodTypeAny, {
-            version: "3" | "4";
-            trackingID?: string | undefined;
-        }, {
-            version: "3" | "4";
-            trackingID?: string | undefined;
-        }>>;
+    trackers: z.ZodOptional<z.ZodArray<z.ZodDiscriminatedUnion<"provider", [z.ZodObject<{
+        provider: z.ZodLiteral<"ga4">;
+        id: z.ZodString;
     }, "strip", z.ZodTypeAny, {
-        tagManagerID?: string | undefined;
-        ga?: {
-            version: "3" | "4";
-            trackingID?: string | undefined;
-        } | undefined;
+        provider: "ga4";
+        id: string;
     }, {
-        tagManagerID?: string | undefined;
-        ga?: {
-            version: "3" | "4";
-            trackingID?: string | undefined;
-        } | undefined;
-    }>>;
+        provider: "ga4";
+        id: string;
+    }>, z.ZodObject<{
+        provider: z.ZodLiteral<"gtm">;
+        id: z.ZodString;
+    }, "strip", z.ZodTypeAny, {
+        provider: "gtm";
+        id: string;
+    }, {
+        provider: "gtm";
+        id: string;
+    }>]>, "many">>;
     serverless: z.ZodObject<{
         enabled: z.ZodDefault<z.ZodBoolean>;
         uploads: z.ZodEnum<["proxy", "remote"]>;
         plugins: z.ZodDefault<z.ZodEnum<["proxy", "remote"]>>;
+        admin: z.ZodDefault<z.ZodEnum<["proxy", "hide"]>>;
+        originProtection: z.ZodDefault<z.ZodObject<{
+            requireLogin: z.ZodDefault<z.ZodOptional<z.ZodBoolean>>;
+        }, "strip", z.ZodTypeAny, {
+            requireLogin: boolean;
+        }, {
+            requireLogin?: boolean | undefined;
+        }>>;
         themeAssets: z.ZodDefault<z.ZodOptional<z.ZodArray<z.ZodString, "many">>>;
-        apiOnly: z.ZodDefault<z.ZodOptional<z.ZodBoolean>>;
         endpoints: z.ZodRecord<z.ZodString, z.ZodString>;
-        defaultRevalidate: z.ZodOptional<z.ZodNumber>;
-        defaultRevalidateQueries: z.ZodOptional<z.ZodNumber>;
+        cors: z.ZodOptional<z.ZodObject<{
+            origins: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
+        }, "strip", z.ZodTypeAny, {
+            origins?: string[] | undefined;
+        }, {
+            origins?: string[] | undefined;
+        }>>;
+        csp: z.ZodDefault<z.ZodObject<{
+            enabled: z.ZodBoolean;
+            autoDetect: z.ZodDefault<z.ZodOptional<z.ZodBoolean>>;
+            nonce: z.ZodDefault<z.ZodOptional<z.ZodBoolean>>;
+            commonOrigins: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
+            values: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodArray<z.ZodString, "many">>>;
+        }, "strip", z.ZodTypeAny, {
+            enabled: boolean;
+            autoDetect: boolean;
+            nonce: boolean;
+            values?: Record<string, string[]> | undefined;
+            commonOrigins?: string[] | undefined;
+        }, {
+            enabled: boolean;
+            values?: Record<string, string[]> | undefined;
+            autoDetect?: boolean | undefined;
+            nonce?: boolean | undefined;
+            commonOrigins?: string[] | undefined;
+        }>>;
     }, "strip", z.ZodTypeAny, {
         enabled: boolean;
         uploads: "proxy" | "remote";
         plugins: "proxy" | "remote";
+        admin: "proxy" | "hide";
+        originProtection: {
+            requireLogin: boolean;
+        };
         themeAssets: string[];
-        apiOnly: boolean;
         endpoints: Record<string, string>;
-        defaultRevalidate?: number | undefined;
-        defaultRevalidateQueries?: number | undefined;
+        csp: {
+            enabled: boolean;
+            autoDetect: boolean;
+            nonce: boolean;
+            values?: Record<string, string[]> | undefined;
+            commonOrigins?: string[] | undefined;
+        };
+        cors?: {
+            origins?: string[] | undefined;
+        } | undefined;
     }, {
         uploads: "proxy" | "remote";
         endpoints: Record<string, string>;
         enabled?: boolean | undefined;
         plugins?: "proxy" | "remote" | undefined;
+        admin?: "proxy" | "hide" | undefined;
+        originProtection?: {
+            requireLogin?: boolean | undefined;
+        } | undefined;
         themeAssets?: string[] | undefined;
-        apiOnly?: boolean | undefined;
-        defaultRevalidate?: number | undefined;
-        defaultRevalidateQueries?: number | undefined;
+        cors?: {
+            origins?: string[] | undefined;
+        } | undefined;
+        csp?: {
+            enabled: boolean;
+            values?: Record<string, string[]> | undefined;
+            autoDetect?: boolean | undefined;
+            nonce?: boolean | undefined;
+            commonOrigins?: string[] | undefined;
+        } | undefined;
     }>;
-    cache: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodObject<{
-        props: z.ZodNumber;
-        queries: z.ZodNumber;
+    cache: z.ZodDefault<z.ZodRecord<z.ZodString, z.ZodObject<{
+        wordpress: z.ZodDefault<z.ZodOptional<z.ZodObject<{
+            /** @deprecated */
+            strategy: z.ZodOptional<z.ZodEnum<["always", "ssr-always-fresh"]>>;
+            cacheHeaders: z.ZodDefault<z.ZodBoolean>;
+            transients: z.ZodDefault<z.ZodBoolean>;
+        }, "strip", z.ZodTypeAny, {
+            cacheHeaders: boolean;
+            transients: boolean;
+            strategy?: "always" | "ssr-always-fresh" | undefined;
+        }, {
+            strategy?: "always" | "ssr-always-fresh" | undefined;
+            cacheHeaders?: boolean | undefined;
+            transients?: boolean | undefined;
+        }>>>;
+        serverless: z.ZodDefault<z.ZodOptional<z.ZodObject<{
+            isr: z.ZodDefault<z.ZodOptional<z.ZodBoolean>>;
+            dataCache: z.ZodDefault<z.ZodEnum<["in-memory", "kv", "none"]>>;
+        }, "strip", z.ZodTypeAny, {
+            isr: boolean;
+            dataCache: "in-memory" | "kv" | "none";
+        }, {
+            isr?: boolean | undefined;
+            dataCache?: "in-memory" | "kv" | "none" | undefined;
+        }>>>;
+        pageDataTTL: z.ZodDefault<z.ZodNumber>;
+        appDataTTL: z.ZodDefault<z.ZodNumber>;
+        queryHooksTTL: z.ZodDefault<z.ZodNumber>;
     }, "strip", z.ZodTypeAny, {
-        props: number;
-        queries: number;
+        wordpress: {
+            cacheHeaders: boolean;
+            transients: boolean;
+            strategy?: "always" | "ssr-always-fresh" | undefined;
+        };
+        serverless: {
+            isr: boolean;
+            dataCache: "in-memory" | "kv" | "none";
+        };
+        pageDataTTL: number;
+        appDataTTL: number;
+        queryHooksTTL: number;
     }, {
-        props: number;
-        queries: number;
+        wordpress?: {
+            strategy?: "always" | "ssr-always-fresh" | undefined;
+            cacheHeaders?: boolean | undefined;
+            transients?: boolean | undefined;
+        } | undefined;
+        serverless?: {
+            isr?: boolean | undefined;
+            dataCache?: "in-memory" | "kv" | "none" | undefined;
+        } | undefined;
+        pageDataTTL?: number | undefined;
+        appDataTTL?: number | undefined;
+        queryHooksTTL?: number | undefined;
     }>>>;
     devUI: z.ZodDefault<z.ZodEnum<["disabled", "enabled"]>>;
 }, "strip", z.ZodTypeAny, {
-    version: "2";
-    legacyMetadata: boolean;
-    legacyStitches: boolean;
     serverless: {
         enabled: boolean;
         uploads: "proxy" | "remote";
         plugins: "proxy" | "remote";
+        admin: "proxy" | "hide";
+        originProtection: {
+            requireLogin: boolean;
+        };
         themeAssets: string[];
-        apiOnly: boolean;
         endpoints: Record<string, string>;
-        defaultRevalidate?: number | undefined;
-        defaultRevalidateQueries?: number | undefined;
+        csp: {
+            enabled: boolean;
+            autoDetect: boolean;
+            nonce: boolean;
+            values?: Record<string, string[]> | undefined;
+            commonOrigins?: string[] | undefined;
+        };
+        cors?: {
+            origins?: string[] | undefined;
+        } | undefined;
     };
+    version: "2";
+    legacyMetadata: boolean;
+    legacyStitches: boolean;
+    cache: Record<string, {
+        wordpress: {
+            cacheHeaders: boolean;
+            transients: boolean;
+            strategy?: "always" | "ssr-always-fresh" | undefined;
+        };
+        serverless: {
+            isr: boolean;
+            dataCache: "in-memory" | "kv" | "none";
+        };
+        pageDataTTL: number;
+        appDataTTL: number;
+        queryHooksTTL: number;
+    }>;
     devUI: "enabled" | "disabled";
     $schema?: string | undefined;
-    tracking?: {
-        tagManagerID?: string | undefined;
-        ga?: {
-            version: "3" | "4";
-            trackingID?: string | undefined;
-        } | undefined;
-    } | undefined;
-    cache?: Record<string, {
-        props: number;
-        queries: number;
-    }> | undefined;
+    trackers?: ({
+        provider: "ga4";
+        id: string;
+    } | {
+        provider: "gtm";
+        id: string;
+    })[] | undefined;
 }, {
-    version: "1" | "2";
     serverless: {
         uploads: "proxy" | "remote";
         endpoints: Record<string, string>;
         enabled?: boolean | undefined;
         plugins?: "proxy" | "remote" | undefined;
+        admin?: "proxy" | "hide" | undefined;
+        originProtection?: {
+            requireLogin?: boolean | undefined;
+        } | undefined;
         themeAssets?: string[] | undefined;
-        apiOnly?: boolean | undefined;
-        defaultRevalidate?: number | undefined;
-        defaultRevalidateQueries?: number | undefined;
+        cors?: {
+            origins?: string[] | undefined;
+        } | undefined;
+        csp?: {
+            enabled: boolean;
+            values?: Record<string, string[]> | undefined;
+            autoDetect?: boolean | undefined;
+            nonce?: boolean | undefined;
+            commonOrigins?: string[] | undefined;
+        } | undefined;
     };
+    version: "1" | "2";
     $schema?: string | undefined;
     legacyMetadata?: boolean | undefined;
     legacyStitches?: boolean | undefined;
-    tracking?: {
-        tagManagerID?: string | undefined;
-        ga?: {
-            version: "3" | "4";
-            trackingID?: string | undefined;
-        } | undefined;
-    } | undefined;
+    trackers?: ({
+        provider: "ga4";
+        id: string;
+    } | {
+        provider: "gtm";
+        id: string;
+    })[] | undefined;
     cache?: Record<string, {
-        props: number;
-        queries: number;
+        wordpress?: {
+            strategy?: "always" | "ssr-always-fresh" | undefined;
+            cacheHeaders?: boolean | undefined;
+            transients?: boolean | undefined;
+        } | undefined;
+        serverless?: {
+            isr?: boolean | undefined;
+            dataCache?: "in-memory" | "kv" | "none" | undefined;
+        } | undefined;
+        pageDataTTL?: number | undefined;
+        appDataTTL?: number | undefined;
+        queryHooksTTL?: number | undefined;
     }> | undefined;
     devUI?: "enabled" | "disabled" | undefined;
 }>;
 export type EDConfig = z.infer<typeof EDConfigSchema>;
+export type EDCacheConfig = z.infer<typeof EDCacheConfigSchema>;
 export declare class Configurator {
     project: Project;
     config?: EDConfig;
@@ -136,3 +326,4 @@ export declare class Configurator {
     private reportError;
     static describeConfig(config: EDConfig, project: Project): string;
 }
+//# sourceMappingURL=config.d.ts.map

package/dist/node/project/config.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"config.d.ts","sourceRoot":"","sources":["../../../src/node/project/config.ts"],"names":[],"mappings":"AAEA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAA;AAKvB,OAAO,EAAE,OAAO,EAAyB,MAAM,cAAc,CAAA;AAE7D,eAAO,MAAM,mBAAmB;;QAG1B,kBAAkB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EA2BtB,CAAA;AAEF,eAAO,MAAM,cAAc;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;YA7BrB,kBAAkB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAkJtB,CAAA;AAEF,MAAM,MAAM,QAAQ,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,cAAc,CAAC,CAAA;AACrD,MAAM,MAAM,aAAa,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,mBAAmB,CAAC,CAAA;AAE/D,qBAAa,YAAY;IAGI,OAAO,EAAE,OAAO;IAF3C,MAAM,CAAC,EAAE,QAAQ,CAAA;IAEjB,OAAO;WAEM,MAAM,CAAC,OAAO,EAAE,OAAO;IAM9B,IAAI;YAQI,kBAAkB;YAYlB,UAAU;IAiCxB,OAAO,CAAC,WAAW;IAOnB,MAAM,CAAC,cAAc,CAAC,MAAM,EAAE,QAAQ,EAAE,OAAO,EAAE,OAAO;CAUzD"}

package/dist/node/project/config.js

@@ -6,6 +6,37 @@ import { cliMode } from "../cli/cli-mode.js";
 import { fs } from "../utils/fs.js";
 import { isDeploying } from "../utils/is-deploying.js";
 import { projectLog as console } from "./project.js";
+export const EDCacheConfigSchema = z.object({
+    wordpress: z
+        .object({
+        /** @deprecated */
+        strategy: z
+            .enum(["always", "ssr-always-fresh"])
+            .optional()
+            .describe("Deprecated. Use cacheHeaders/transients instead."),
+        cacheHeaders: z.boolean().default(true).describe("Whether to add caching headers to data requests."),
+        transients: z.boolean().default(true).describe("Whether to cache within transients."),
+    })
+        .optional()
+        .default({ strategy: "always", cacheHeaders: true, transients: true }),
+    serverless: z
+        .object({
+        isr: z
+            .boolean()
+            .optional()
+            .default(true)
+            .describe("Whether to use Incremental Static Regeneration for this origin."),
+        dataCache: z
+            .enum(["in-memory", "kv", "none"])
+            .default("in-memory")
+            .describe("The cache strategy to use for page data."),
+    })
+        .optional()
+        .default({ isr: true, dataCache: "in-memory" }),
+    pageDataTTL: z.number().default(300).describe("The number of seconds to cache page data."),
+    appDataTTL: z.number().default(300).describe("The number of seconds to cache global app data."),
+    queryHooksTTL: z.number().default(300).describe("The number of seconds to cache named GraphQL queries."),
+});
 export const EDConfigSchema = z.object({
     $schema: z.string().optional(),
     version: z.enum(["1", "2"]).refine((v) => v === "2", { message: "Only version 2 is supported" }),
@@ -15,16 +46,18 @@ export const EDConfigSchema = z.object({
         .default(false)
         .describe("Whether to use legacy comments or exported JSON for block and view metadata"),
     legacyStitches: z.boolean().optional().default(true).describe("Whether this site is using Stitches"),
-    tracking: z
-        .object({
-        tagManagerID: z.string().optional(),
-        ga: z
-            .object({
-            trackingID: z.string().optional(),
-            version: z.enum(["3", "4"]),
-        })
-            .optional(),
-    })
+    trackers: z
+        .array(z.discriminatedUnion("provider", [
+        z.object({
+            provider: z.literal("ga4"),
+            id: z.string().describe("The Google Analytics 4 tracking ID"),
+        }),
+        z.object({
+            provider: z.literal("gtm"),
+            id: z.string().describe("The Google Tag Manager project ID (eg. GTM-XXXXXXX)"),
+        }),
+    ]))
+        .describe("An array of standard tracking codes to embed")
         .optional(),
     serverless: z.object({
         enabled: z.boolean().default(true).describe("Whether to deploy the site as a serverless app"),
@@ -35,25 +68,71 @@ export const EDConfigSchema = z.object({
             .enum(["proxy", "remote"])
             .default("remote")
             .describe("Whether to proxy plugin assets or serve them from the serverless endpoint.\nDefault is `remote`, but `proxy` can be used to hide the CMS origin."),
-        // theme: z.enum(["proxy", "copy", "remote"]),
+        admin: z
+            .enum(["proxy", "hide"])
+            .default("proxy")
+            .describe("How to handle the WordPress admin URLs.\nDefault is `proxy`, which will proxy the admin URLs to the CMS origin. When set to `hide`, all /wp-admin, /wp-json and /wp-login.php URLs will show a 404 page.\nHas no effect in dev mode."),
+        originProtection: z
+            .object({
+            requireLogin: z
+                .boolean()
+                .optional()
+                .default(false)
+                .describe("Enabling this will prevent access to the frontend for non-logged-in users on the CMS origin (eg. Flywheel, WPEngine), but allow access to the serverless frontend (eg. Vercel)."),
+        })
+            .default({}),
         themeAssets: z
             .array(z.string())
             .optional()
             .default(["assets"])
-            .describe('Files to include in a serverless deployment.\nDefault is `["assets"]`'),
-        apiOnly: z.boolean().optional().default(false).describe("Whether to deploy only the API, not the frontend"),
+            .describe('Asset folders to include in a serverless deployment.\nDefault is `["assets"]`'),
         endpoints: z
             .record(z.string(), z.string())
             .describe("A map of WordPress hostnames -> serverless hostnames. You can use `*` as a wildcard for the key.\n\nFor example, `{'cms.ed.studio': 'ed.studio'}` tells the WordPress frontend where it can find any serverless API endpoints."),
-        defaultRevalidate: z.number().optional(),
-        defaultRevalidateQueries: z.number().optional(),
+        cors: z
+            .object({
+            origins: z
+                .array(z.string())
+                .optional()
+                .describe("A list of allowed origins for CORS. Set to ['*'] to allow all. All WordPress hosts are also allowed."),
+        })
+            .optional(),
+        csp: z
+            .object({
+            enabled: z.boolean(),
+            autoDetect: z
+                .boolean()
+                .optional()
+                .default(true)
+                .describe("Whether to auto-detect CSP origins from the tracking scripts, and wp_head/wp_footer scripts and styles."),
+            nonce: z
+                .boolean()
+                .optional()
+                .default(false)
+                .describe("Whether to use nonces for scripts and styles. The nonce attribute will be applied to all tracking snipets, and styles/scripts used in wp_head/wp_footer."),
+            commonOrigins: z
+                .string()
+                .array()
+                .describe("A list of common origins, to be shared amoungst all directives. Items should be things like 'hubspot.com' or '*.hubspot.com'")
+                .optional(),
+            values: z
+                .record(z.string().array())
+                .optional()
+                .describe("A map of CSP directives to their values. Keys should be camelCase."),
+        })
+            .default({ enabled: false })
+            .describe("Content Security Policy settings"),
     }),
     cache: z
-        .record(z.string(), z.object({
-        props: z.number(),
-        queries: z.number(),
-    }))
-        .optional(),
+        .record(EDCacheConfigSchema)
+        .default({
+        "*": {
+            pageDataTTL: 300,
+            appDataTTL: 300,
+            queryHooksTTL: 300,
+        },
+    })
+        .describe("A map of WordPress origin hostnames -> cache settings. Wildcards can be used for each domain."),
     devUI: z.enum(["disabled", "enabled"]).default("enabled"),
 });
 export class Configurator {
@@ -115,7 +194,7 @@ export class Configurator {
             this.config = undefined;
             if (exitOnError) {
                 console.flush();
-                process.exit(0);
+                process.exit(1);
             }
         }
     }

package/dist/node/project/eddev-build-file.d.ts

@@ -8,3 +8,4 @@ export declare class BuildInfoWriter {
     watch(): void;
     write(): Promise<void>;
 }
+//# sourceMappingURL=eddev-build-file.d.ts.map

package/dist/node/project/eddev-build-file.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"eddev-build-file.d.ts","sourceRoot":"","sources":["../../../src/node/project/eddev-build-file.ts"],"names":[],"mappings":"AAEA,OAAO,KAAK,EAAE,OAAO,EAAE,MAAM,cAAc,CAAA;AAG3C;;GAEG;AACH,qBAAa,eAAe;IACP,OAAO,EAAE,OAAO;gBAAhB,OAAO,EAAE,OAAO;IAEnC,KAAK;IAUC,KAAK;CAgEZ"}

package/dist/node/project/eddev-build-file.js

@@ -53,14 +53,16 @@ export class BuildInfoWriter {
                         align_text: false,
                         align_center: false,
                         multiple: block.allowMultiple ? true : false,
-                        mode: block.mode ?? "preview",
+                        mode: block.mode === "both" ? true : false,
                         customClassName: false,
                         inserter: block.inserter,
                     },
-                    mode: block.mode ?? "preview",
+                    mode: block.mode === "edit" ? "edit" : "preview",
                     canCache: block.cache,
                     frontendMode: block.frontendMode,
                     postmeta: block.postMetaBlock,
+                    blockStyles: block.blockStyles,
+                    defaultBlockStyle: block.blockStyles?.find((s) => s.isDefault)?.name,
                 };
             }),
             templates: Object.values(viewManifest.views)

package/dist/node/project/env.d.ts

@@ -5,22 +5,26 @@ export declare const fields: {
     readonly SITE_URL: z.ZodString;
     readonly DEV_HOT_PORT: z.ZodEffects<z.ZodEffects<z.ZodDefault<z.ZodString>, string | number, string | undefined>, number, string | undefined>;
     readonly DEV_SERVERLESS_PORT: z.ZodEffects<z.ZodEffects<z.ZodDefault<z.ZodString>, string | number, string | undefined>, number, string | undefined>;
+    readonly SITE_API_KEY: z.ZodOptional<z.ZodString>;
 };
 export declare const ProjectEnvSchema: z.ZodObject<{
     readonly DEBUG_GRAPHQL_URL: z.ZodOptional<z.ZodString>;
     readonly SITE_URL: z.ZodOptional<z.ZodString>;
     readonly DEV_HOT_PORT: z.ZodOptional<z.ZodEffects<z.ZodEffects<z.ZodDefault<z.ZodString>, string | number, string | undefined>, number, string | undefined>>;
     readonly DEV_SERVERLESS_PORT: z.ZodOptional<z.ZodEffects<z.ZodEffects<z.ZodDefault<z.ZodString>, string | number, string | undefined>, number, string | undefined>>;
+    readonly SITE_API_KEY: z.ZodOptional<z.ZodOptional<z.ZodString>>;
 }, "strip", z.ZodTypeAny, {
     DEBUG_GRAPHQL_URL?: string | undefined;
     SITE_URL?: string | undefined;
     DEV_HOT_PORT?: number | undefined;
     DEV_SERVERLESS_PORT?: number | undefined;
+    SITE_API_KEY?: string | undefined;
 }, {
     DEBUG_GRAPHQL_URL?: string | undefined;
     SITE_URL?: string | undefined;
     DEV_HOT_PORT?: string | undefined;
     DEV_SERVERLESS_PORT?: string | undefined;
+    SITE_API_KEY?: string | undefined;
 }>;
 export type ProjectEnvKey = keyof typeof fields;
 export declare const ProjectEnvUtils: {
@@ -37,3 +41,4 @@ export declare const ProjectEnvUtils: {
     getSafe<T extends ProjectEnvKey>(key: T): Required<ProjectEnvMap[T]> | undefined;
     get<T extends ProjectEnvKey>(key: T, cons?: import("../utils/stateful-log.js").StatefulLog<import("./project.js").Project>): z.infer<(typeof fields)[T]>;
 };
+//# sourceMappingURL=env.d.ts.map

package/dist/node/project/env.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"env.d.ts","sourceRoot":"","sources":["../../../src/node/project/env.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAA;AAKvB,MAAM,MAAM,aAAa,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,gBAAgB,CAAC,CAAA;AAQ5D,eAAO,MAAM,MAAM;;;;;;CAWT,CAAA;AAEV,eAAO,MAAM,gBAAgB;;;;;;;;;;;;;;;;;;EAA6B,CAAA;AAE1D,MAAM,MAAM,aAAa,GAAG,MAAM,OAAO,MAAM,CAAA;AAE/C,eAAO,MAAM,eAAe;IAC1B;;;OAGG;sBACe,OAAO,GAAG;QAAE,KAAK,EAAE,IAAI,CAAC;QAAC,GAAG,EAAE,aAAa,CAAA;KAAE,GAAG;QAAE,KAAK,EAAE,KAAK,CAAA;KAAE;YA2B1E,CAAC,SAAS,aAAa,OAAO,CAAC,GAAG,QAAQ,CAAC,aAAa,CAAC,CAAC,CAAC,CAAC,GAAG,SAAS;QAQ5E,CAAC,SAAS,aAAa,OAAO,CAAC,0FAAmB,CAAC,CAAC,KAAK,CAAC,CAAC,OAAO,MAAM,EAAE,CAAC,CAAC,CAAC;CAclF,CAAA"}

package/dist/node/project/env.js

@@ -15,6 +15,7 @@ export const fields = {
     SITE_URL: z.string().url().describe("The URL of the site"),
     DEV_HOT_PORT: portNumber,
     DEV_SERVERLESS_PORT: portNumber,
+    SITE_API_KEY: z.string().optional().describe("The API key for the site, when origin protection is enabled"),
 };
 export const ProjectEnvSchema = z.object(fields).partial();
 export const ProjectEnvUtils = {

package/dist/node/project/favicons.d.ts

@@ -0,0 +1 @@
+//# sourceMappingURL=favicons.d.ts.map

package/dist/node/project/favicons.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"favicons.d.ts","sourceRoot":"","sources":["../../../src/node/project/favicons.ts"],"names":[],"mappings":""}

package/dist/node/project/manifest/block-manifest.d.ts

@@ -17,3 +17,4 @@ type BlockLoadResult = {
 export type BlockManifestGenerator = ReturnType<typeof loadBlockManifest>;
 export declare function loadBlockManifest(project: Project): import("./manifest.js").ManifestGenerator<BlockLoadResult, BlockManifest>;
 export {};
+//# sourceMappingURL=block-manifest.d.ts.map

package/dist/node/project/manifest/block-manifest.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"block-manifest.d.ts","sourceRoot":"","sources":["../../../../src/node/project/manifest/block-manifest.ts"],"names":[],"mappings":"AAEA,OAAO,EAAmB,aAAa,EAAE,wBAAwB,EAAE,MAAM,2BAA2B,CAAA;AAIpG,OAAO,EAAE,OAAO,EAAE,MAAM,eAAe,CAAA;AAMvC,MAAM,MAAM,aAAa,GAAG;IAC1B,MAAM,EAAE;QACN,CAAC,CAAC,EAAE,MAAM,GAAG,aAAa,CAAA;KAC3B,CAAA;IACD,kBAAkB,EAAE;QAClB,QAAQ,EAAE,MAAM,CAAA;QAChB,OAAO,EAAE,MAAM,CAAA;QACf,QAAQ,EAAE,OAAO,GAAG,SAAS,CAAA;KAC9B,EAAE,CAAA;CACJ,CAAA;AAED,KAAK,eAAe,GAAG;IACrB,IAAI,EAAE,wBAAwB,GAAG,IAAI,CAAA;IACrC,KAAK,CAAC,EAAE,MAAM,CAAA;CACf,CAAA;AAED,MAAM,MAAM,sBAAsB,GAAG,UAAU,CAAC,OAAO,iBAAiB,CAAC,CAAA;AAEzE,wBAAgB,iBAAiB,CAAC,OAAO,EAAE,OAAO,6EA0GjD"}