webstudio 0.290.0 → 0.291.0

package/lib/cli.js

@@ -560,85 +560,88 @@ const getFontFormat = (asset2) => {
   const extension2 = asset2.name.slice(asset2.name.lastIndexOf(".") + 1);
   return FONT_FORMATS.has(extension2) ? FONT_FORMATS.get(extension2) ?? asset2.format : FONT_FORMATS.get(asset2.format) ?? asset2.format;
 };
-const formatFace = (asset2, format2, url2) => {
+const formatFace = ({ asset: asset2, format: format2, style, url: url2 }) => {
+  const face = {
+    fontFamily: asset2.meta.family,
+    fontStyle: style,
+    fontDisplay: "swap",
+    src: `url(${sanitizeCssUrl$1(url2)}) format("${format2}")`
+  };
   if ("variationAxes" in asset2.meta) {
-    const { wght, wdth } = asset2.meta?.variationAxes ?? {};
+    const { wght, wdth } = asset2.meta.variationAxes;
     return {
-      fontFamily: asset2.meta.family,
-      fontStyle: "normal",
-      fontDisplay: "swap",
-      src: `url(${sanitizeCssUrl$1(url2)}) format("${format2}")`,
+      ...face,
       fontStretch: wdth ? `${wdth.min}% ${wdth.max}%` : void 0,
       fontWeight: wght ? `${wght.min} ${wght.max}` : void 0
     };
   }
   return {
-    fontFamily: asset2.meta.family,
-    fontStyle: asset2.meta.style,
-    fontWeight: asset2.meta.weight,
-    fontDisplay: "swap",
-    src: `url(${sanitizeCssUrl$1(url2)}) format("${format2}")`
+    ...face,
+    fontWeight: asset2.meta.weight
   };
 };
-const getKey = (asset2) => {
+const getKey = (asset2, style) => {
   if ("variationAxes" in asset2.meta) {
-    return asset2.meta.family + Object.values(asset2.meta.variationAxes).join("");
+    const { wght, wdth } = asset2.meta.variationAxes;
+    return JSON.stringify([asset2.meta.family, style, wght, wdth]);
+  }
+  return JSON.stringify([asset2.meta.family, style, asset2.meta.weight]);
+};
+const getStyles$1 = (meta2) => {
+  const styles = /* @__PURE__ */ new Set([meta2.style]);
+  if ("variationAxes" in meta2) {
+    const { ital, slnt } = meta2.variationAxes;
+    if (ital !== void 0 && ital.min <= 0 && ital.max >= 1) {
+      styles.add("normal");
+      styles.add("italic");
+    }
+    if (slnt !== void 0 && slnt.min < slnt.max && slnt.min <= 0 && slnt.max >= 0) {
+      styles.add("normal");
+      styles.add("oblique");
+    }
   }
-  return asset2.meta.family + asset2.meta.style + asset2.meta.weight;
+  return Array.from(styles);
 };
 const getFontFaces = (assets, options) => {
   const { assetBaseUrl } = options;
   const faces = /* @__PURE__ */ new Map();
-  const seenUrls = /* @__PURE__ */ new Set();
+  const seenSources = /* @__PURE__ */ new Set();
   for (const asset2 of assets) {
     const url2 = `${assetBaseUrl}${asset2.name}`;
-    const assetKey = getKey(asset2);
-    if (seenUrls.has(url2)) {
-      continue;
-    }
-    seenUrls.add(url2);
-    const format2 = getFontFormat(asset2);
-    const sources = faces.get(assetKey) ?? /* @__PURE__ */ new Map();
-    const existing = sources.get(format2);
-    if (existing === void 0 || url2 < existing.url) {
-      sources.set(format2, { asset: asset2, format: format2, url: url2 });
+    for (const style of getStyles$1(asset2.meta)) {
+      const sourceKey = JSON.stringify([url2, style]);
+      if (seenSources.has(sourceKey)) {
+        continue;
+      }
+      seenSources.add(sourceKey);
+      const assetKey = getKey(asset2, style);
+      const format2 = getFontFormat(asset2);
+      const sources = faces.get(assetKey) ?? /* @__PURE__ */ new Map();
+      const existing = sources.get(format2);
+      if (existing === void 0 || url2 < existing.url) {
+        sources.set(format2, { asset: asset2, format: format2, style, url: url2 });
+      }
+      faces.set(assetKey, sources);
     }
-    faces.set(assetKey, sources);
   }
   return Array.from(faces.values(), (sources) => {
-    const [{ asset: asset2, format: format2, url: url2 }, ...fallbacks] = Array.from(
-      sources.values()
-    ).sort(
+    const [source, ...fallbacks] = Array.from(sources.values()).sort(
       (left, right) => fontFormatOrder.indexOf(left.format) - fontFormatOrder.indexOf(right.format)
     );
-    const face = formatFace(asset2, format2, url2);
+    const face = formatFace(source);
     face.src += fallbacks.map(
       ({ format: fallbackFormat, url: fallbackUrl }) => `, url(${sanitizeCssUrl$1(fallbackUrl)}) format("${fallbackFormat}")`
     ).join("");
     return face;
   });
 };
+const fontStyle = z$4.enum(FONT_STYLES);
 const fontFormat = z$4.union([
   z$4.literal("ttf"),
   z$4.literal("woff"),
   z$4.literal("woff2")
 ]);
-const axisName = z$4.enum([
-  "wght",
-  "wdth",
-  "slnt",
-  "opsz",
-  "ital",
-  "GRAD",
-  "XTRA",
-  "XOPQ",
-  "YOPQ",
-  "YTLC",
-  "YTUC",
-  "YTAS",
-  "YTDE",
-  "YTFI"
-]);
+const axisName = z$4.string().regex(/^[A-Za-z][A-Za-z0-9]* *$/).length(4);
 const variationAxes = z$4.partialRecord(
   axisName,
   z$4.object({
@@ -650,33 +653,38 @@ const variationAxes = z$4.partialRecord(
 );
 const fontMetaStatic = z$4.object({
   family: z$4.string(),
-  style: z$4.enum(FONT_STYLES),
+  style: fontStyle,
   weight: z$4.number()
 });
 const fontMetaVariable = z$4.object({
   family: z$4.string(),
+  style: fontStyle.default("normal"),
   variationAxes
 });
 const fontMeta = z$4.union([fontMetaStatic, fontMetaVariable]);
 const fontMetaUpdate = z$4.union([
   fontMetaStatic.partial().strict(),
-  fontMetaVariable.partial().strict()
+  z$4.object({
+    family: fontMetaVariable.shape.family.optional(),
+    style: fontStyle.optional(),
+    variationAxes: fontMetaVariable.shape.variationAxes.optional()
+  }).strict()
 ]);
 const mergeFontMeta = (current4, override) => {
   const result2 = fontMetaUpdate.safeParse(override);
   if (result2.success === false) {
     return;
   }
-  const { family } = result2.data;
+  const { family, style } = result2.data;
   if ("variationAxes" in current4) {
     const variationAxes2 = "variationAxes" in result2.data ? result2.data.variationAxes : void 0;
     return {
       ...current4,
       ...family === void 0 ? {} : { family },
+      ...style === void 0 ? {} : { style },
       ...variationAxes2 === void 0 ? {} : { variationAxes: variationAxes2 }
     };
   }
-  const style = "style" in result2.data ? result2.data.style : void 0;
   const weight = "weight" in result2.data ? result2.data.weight : void 0;
   return {
     ...current4,
@@ -18134,6 +18142,17 @@ const pages = z$4.object({
 }).superRefine((pages2, context) => {
   const homePage = pages2.pages.get(pages2.homePageId);
   const rootFolder = pages2.folders.get(pages2.rootFolderId);
+  const folderIndexPageIds = /* @__PURE__ */ new Set();
+  for (const [folderId2, folder2] of pages2.folders) {
+    if (folderId2 === pages2.rootFolderId) {
+      continue;
+    }
+    for (const childId of folder2.children) {
+      if (pages2.pages.has(childId)) {
+        folderIndexPageIds.add(childId);
+      }
+    }
+  }
   if (homePage === void 0) {
     context.addIssue({
       code: z$4.ZodIssueCode.custom,
@@ -18163,7 +18182,7 @@ const pages = z$4.object({
         message: "Page id must match its record key"
       });
     }
-    if (pageId2 !== pages2.homePageId && page2.path === "") {
+    if (pageId2 !== pages2.homePageId && page2.path === "" && folderIndexPageIds.has(pageId2) === false) {
       context.addIssue({
         code: z$4.ZodIssueCode.custom,
         path: ["pages", pageId2, "path"],
@@ -19018,14 +19037,14 @@ class FontFaceRule {
       return this.#cached;
     }
     const decls = [];
-    const { fontFamily, fontStyle, fontWeight, fontDisplay, src } = this.#options;
+    const { fontFamily, fontStyle: fontStyle2, fontWeight, fontDisplay, src } = this.#options;
     const value2 = toValue(
       { type: "fontFamily", value: [fontFamily] },
       // Avoids adding a fallback automatically which needs to happen for font family in general but not for font face.
       (value22) => value22
     );
     decls.push(`font-family: ${value2}`);
-    decls.push(`font-style: ${fontStyle}`);
+    decls.push(`font-style: ${fontStyle2}`);
     decls.push(`font-weight: ${fontWeight}`);
     decls.push(`font-display: ${fontDisplay}`);
     decls.push(`src: ${src}`);
@@ -24912,10 +24931,10 @@ const extractFontMetadata = (asset2) => {
     return;
   }
   const metadata = {
-    family: asset2.meta.family
+    family: asset2.meta.family,
+    style: asset2.meta.style
   };
-  if ("style" in asset2.meta) {
-    metadata.style = asset2.meta.style;
+  if ("weight" in asset2.meta) {
     metadata.weight = asset2.meta.weight;
   }
   return metadata;
@@ -30881,26 +30900,18 @@ const runtimeOperationContractData = [
                                       family: {
                                         type: "string"
                                       },
+                                      style: {
+                                        default: "normal",
+                                        type: "string",
+                                        enum: ["normal", "italic", "oblique"]
+                                      },
                                       variationAxes: {
                                         type: "object",
                                         propertyNames: {
                                           type: "string",
-                                          enum: [
-                                            "wght",
-                                            "wdth",
-                                            "slnt",
-                                            "opsz",
-                                            "ital",
-                                            "GRAD",
-                                            "XTRA",
-                                            "XOPQ",
-                                            "YOPQ",
-                                            "YTLC",
-                                            "YTUC",
-                                            "YTAS",
-                                            "YTDE",
-                                            "YTFI"
-                                          ]
+                                          minLength: 4,
+                                          maxLength: 4,
+                                          pattern: "^[A-Za-z][A-Za-z0-9]* *$"
                                         },
                                         additionalProperties: {
                                           type: "object",
@@ -33981,26 +33992,18 @@ const runtimeOperationContractData = [
                                       family: {
                                         type: "string"
                                       },
+                                      style: {
+                                        default: "normal",
+                                        type: "string",
+                                        enum: ["normal", "italic", "oblique"]
+                                      },
                                       variationAxes: {
                                         type: "object",
                                         propertyNames: {
                                           type: "string",
-                                          enum: [
-                                            "wght",
-                                            "wdth",
-                                            "slnt",
-                                            "opsz",
-                                            "ital",
-                                            "GRAD",
-                                            "XTRA",
-                                            "XOPQ",
-                                            "YOPQ",
-                                            "YTLC",
-                                            "YTUC",
-                                            "YTAS",
-                                            "YTDE",
-                                            "YTFI"
-                                          ]
+                                          minLength: 4,
+                                          maxLength: 4,
+                                          pattern: "^[A-Za-z][A-Za-z0-9]* *$"
                                         },
                                         additionalProperties: {
                                           type: "object",
@@ -37092,26 +37095,18 @@ const runtimeOperationContractData = [
                                       family: {
                                         type: "string"
                                       },
+                                      style: {
+                                        default: "normal",
+                                        type: "string",
+                                        enum: ["normal", "italic", "oblique"]
+                                      },
                                       variationAxes: {
                                         type: "object",
                                         propertyNames: {
                                           type: "string",
-                                          enum: [
-                                            "wght",
-                                            "wdth",
-                                            "slnt",
-                                            "opsz",
-                                            "ital",
-                                            "GRAD",
-                                            "XTRA",
-                                            "XOPQ",
-                                            "YOPQ",
-                                            "YTLC",
-                                            "YTUC",
-                                            "YTAS",
-                                            "YTDE",
-                                            "YTFI"
-                                          ]
+                                          minLength: 4,
+                                          maxLength: 4,
+                                          pattern: "^[A-Za-z][A-Za-z0-9]* *$"
                                         },
                                         additionalProperties: {
                                           type: "object",
@@ -40192,26 +40187,18 @@ const runtimeOperationContractData = [
                                       family: {
                                         type: "string"
                                       },
+                                      style: {
+                                        default: "normal",
+                                        type: "string",
+                                        enum: ["normal", "italic", "oblique"]
+                                      },
                                       variationAxes: {
                                         type: "object",
                                         propertyNames: {
                                           type: "string",
-                                          enum: [
-                                            "wght",
-                                            "wdth",
-                                            "slnt",
-                                            "opsz",
-                                            "ital",
-                                            "GRAD",
-                                            "XTRA",
-                                            "XOPQ",
-                                            "YOPQ",
-                                            "YTLC",
-                                            "YTUC",
-                                            "YTAS",
-                                            "YTDE",
-                                            "YTFI"
-                                          ]
+                                          minLength: 4,
+                                          maxLength: 4,
+                                          pattern: "^[A-Za-z][A-Za-z0-9]* *$"
                                         },
                                         additionalProperties: {
                                           type: "object",
@@ -46000,26 +45987,22 @@ const runtimeOperationContractData = [
                                             family: {
                                               type: "string"
                                             },
+                                            style: {
+                                              default: "normal",
+                                              type: "string",
+                                              enum: [
+                                                "normal",
+                                                "italic",
+                                                "oblique"
+                                              ]
+                                            },
                                             variationAxes: {
                                               type: "object",
                                               propertyNames: {
                                                 type: "string",
-                                                enum: [
-                                                  "wght",
-                                                  "wdth",
-                                                  "slnt",
-                                                  "opsz",
-                                                  "ital",
-                                                  "GRAD",
-                                                  "XTRA",
-                                                  "XOPQ",
-                                                  "YOPQ",
-                                                  "YTLC",
-                                                  "YTUC",
-                                                  "YTAS",
-                                                  "YTDE",
-                                                  "YTFI"
-                                                ]
+                                                minLength: 4,
+                                                maxLength: 4,
+                                                pattern: "^[A-Za-z][A-Za-z0-9]* *$"
                                               },
                                               additionalProperties: {
                                                 type: "object",
@@ -49141,26 +49124,22 @@ const runtimeOperationContractData = [
                                             family: {
                                               type: "string"
                                             },
+                                            style: {
+                                              default: "normal",
+                                              type: "string",
+                                              enum: [
+                                                "normal",
+                                                "italic",
+                                                "oblique"
+                                              ]
+                                            },
                                             variationAxes: {
                                               type: "object",
                                               propertyNames: {
                                                 type: "string",
-                                                enum: [
-                                                  "wght",
-                                                  "wdth",
-                                                  "slnt",
-                                                  "opsz",
-                                                  "ital",
-                                                  "GRAD",
-                                                  "XTRA",
-                                                  "XOPQ",
-                                                  "YOPQ",
-                                                  "YTLC",
-                                                  "YTUC",
-                                                  "YTAS",
-                                                  "YTDE",
-                                                  "YTFI"
-                                                ]
+                                                minLength: 4,
+                                                maxLength: 4,
+                                                pattern: "^[A-Za-z][A-Za-z0-9]* *$"
                                               },
                                               additionalProperties: {
                                                 type: "object",
@@ -63312,26 +63291,18 @@ const runtimeOperationContractData = [
                                       family: {
                                         type: "string"
                                       },
+                                      style: {
+                                        default: "normal",
+                                        type: "string",
+                                        enum: ["normal", "italic", "oblique"]
+                                      },
                                       variationAxes: {
                                         type: "object",
                                         propertyNames: {
                                           type: "string",
-                                          enum: [
-                                            "wght",
-                                            "wdth",
-                                            "slnt",
-                                            "opsz",
-                                            "ital",
-                                            "GRAD",
-                                            "XTRA",
-                                            "XOPQ",
-                                            "YOPQ",
-                                            "YTLC",
-                                            "YTUC",
-                                            "YTAS",
-                                            "YTDE",
-                                            "YTFI"
-                                          ]
+                                          minLength: 4,
+                                          maxLength: 4,
+                                          pattern: "^[A-Za-z][A-Za-z0-9]* *$"
                                         },
                                         additionalProperties: {
                                           type: "object",
@@ -66206,9 +66177,11 @@ const runtimeOperationContractData = [
                 },
                 conflictResolution: {
                   type: "string",
-                  enum: ["ours", "theirs", "merge"]
+                  enum: ["ours", "theirs", "merge"],
+                  description: 'How to resolve incoming design tokens that share a name with an existing token. "ours" keeps the existing token styles and id, "theirs" uses incoming styles, and "merge" combines both.'
                 },
                 contentMode: {
+                  description: "Apply content-mode copy restrictions to props and styles while reusing existing tokens and breakpoints.",
                   type: "boolean"
                 },
                 mode: {
@@ -66484,26 +66457,18 @@ const runtimeOperationContractData = [
                                       family: {
                                         type: "string"
                                       },
+                                      style: {
+                                        default: "normal",
+                                        type: "string",
+                                        enum: ["normal", "italic", "oblique"]
+                                      },
                                       variationAxes: {
                                         type: "object",
                                         propertyNames: {
                                           type: "string",
-                                          enum: [
-                                            "wght",
-                                            "wdth",
-                                            "slnt",
-                                            "opsz",
-                                            "ital",
-                                            "GRAD",
-                                            "XTRA",
-                                            "XOPQ",
-                                            "YOPQ",
-                                            "YTLC",
-                                            "YTUC",
-                                            "YTAS",
-                                            "YTDE",
-                                            "YTFI"
-                                          ]
+                                          minLength: 4,
+                                          maxLength: 4,
+                                          pattern: "^[A-Za-z][A-Za-z0-9]* *$"
                                         },
                                         additionalProperties: {
                                           type: "object",
@@ -72764,26 +72729,18 @@ const runtimeOperationContractData = [
                               family: {
                                 type: "string"
                               },
+                              style: {
+                                default: "normal",
+                                type: "string",
+                                enum: ["normal", "italic", "oblique"]
+                              },
                               variationAxes: {
                                 type: "object",
                                 propertyNames: {
                                   type: "string",
-                                  enum: [
-                                    "wght",
-                                    "wdth",
-                                    "slnt",
-                                    "opsz",
-                                    "ital",
-                                    "GRAD",
-                                    "XTRA",
-                                    "XOPQ",
-                                    "YOPQ",
-                                    "YTLC",
-                                    "YTUC",
-                                    "YTAS",
-                                    "YTDE",
-                                    "YTFI"
-                                  ]
+                                  minLength: 4,
+                                  maxLength: 4,
+                                  pattern: "^[A-Za-z][A-Za-z0-9]* *$"
                                 },
                                 additionalProperties: {
                                   type: "object",
@@ -78581,26 +78538,18 @@ const runtimeOperationContractData = [
                               family: {
                                 type: "string"
                               },
+                              style: {
+                                default: "normal",
+                                type: "string",
+                                enum: ["normal", "italic", "oblique"]
+                              },
                               variationAxes: {
                                 type: "object",
                                 propertyNames: {
                                   type: "string",
-                                  enum: [
-                                    "wght",
-                                    "wdth",
-                                    "slnt",
-                                    "opsz",
-                                    "ital",
-                                    "GRAD",
-                                    "XTRA",
-                                    "XOPQ",
-                                    "YOPQ",
-                                    "YTLC",
-                                    "YTUC",
-                                    "YTAS",
-                                    "YTDE",
-                                    "YTFI"
-                                  ]
+                                  minLength: 4,
+                                  maxLength: 4,
+                                  pattern: "^[A-Za-z][A-Za-z0-9]* *$"
                                 },
                                 additionalProperties: {
                                   type: "object",
@@ -81360,9 +81309,11 @@ const runtimeOperationContractData = [
         },
         conflictResolution: {
           type: "string",
-          enum: ["ours", "theirs", "merge"]
+          enum: ["ours", "theirs", "merge"],
+          description: 'How to resolve incoming design tokens that share a name with an existing token. "ours" keeps the existing token styles and id, "theirs" uses incoming styles, and "merge" combines both.'
         },
         contentMode: {
+          description: "Apply content-mode copy restrictions to props and styles while reusing existing tokens and breakpoints.",
           type: "boolean"
         },
         mode: {
@@ -97239,26 +97190,17 @@ const runtimeOperationContractData = [
                         family: {
                           type: "string"
                         },
+                        style: {
+                          type: "string",
+                          enum: ["normal", "italic", "oblique"]
+                        },
                         variationAxes: {
                           type: "object",
                           propertyNames: {
                             type: "string",
-                            enum: [
-                              "wght",
-                              "wdth",
-                              "slnt",
-                              "opsz",
-                              "ital",
-                              "GRAD",
-                              "XTRA",
-                              "XOPQ",
-                              "YOPQ",
-                              "YTLC",
-                              "YTUC",
-                              "YTAS",
-                              "YTDE",
-                              "YTFI"
-                            ]
+                            minLength: 4,
+                            maxLength: 4,
+                            pattern: "^[A-Za-z][A-Za-z0-9]* *$"
                           },
                           additionalProperties: {
                             type: "object",
@@ -97305,7 +97247,7 @@ const runtimeOperationContractData = [
                   required: []
                 }
               ],
-              description: "Type-specific metadata: family/style/weight or variationAxes for fonts, width/height for images, and no fields for generic files."
+              description: "Type-specific metadata: family and style plus weight for static fonts or variationAxes for variable fonts, width/height for images, and no fields for generic files."
             }
           },
           required: []
@@ -97498,26 +97440,18 @@ const runtimeOperationContractData = [
                         family: {
                           type: "string"
                         },
+                        style: {
+                          default: "normal",
+                          type: "string",
+                          enum: ["normal", "italic", "oblique"]
+                        },
                         variationAxes: {
                           type: "object",
                           propertyNames: {
                             type: "string",
-                            enum: [
-                              "wght",
-                              "wdth",
-                              "slnt",
-                              "opsz",
-                              "ital",
-                              "GRAD",
-                              "XTRA",
-                              "XOPQ",
-                              "YOPQ",
-                              "YTLC",
-                              "YTUC",
-                              "YTAS",
-                              "YTDE",
-                              "YTFI"
-                            ]
+                            minLength: 4,
+                            maxLength: 4,
+                            pattern: "^[A-Za-z][A-Za-z0-9]* *$"
                           },
                           additionalProperties: {
                             type: "object",
@@ -99227,7 +99161,7 @@ const assetUpdateInput = z$4.object({
     description: z$4.union([z$4.string(), z$4.null()]).optional(),
     folderId: z$4.union([z$4.string().min(1), z$4.null()]).optional(),
     meta: assetMetaUpdate.describe(
-      "Type-specific metadata: family/style/weight or variationAxes for fonts, width/height for images, and no fields for generic files."
+      "Type-specific metadata: family and style plus weight for static fonts or variationAxes for variable fonts, width/height for images, and no fields for generic files."
     ).optional()
   }).refine(
     (values) => Object.keys(values).length > 0,
@@ -118200,7 +118134,7 @@ const expandBorderImage = function* (value2) {
   yield ["border-image-repeat", repeat ?? createInitialNode()];
 };
 const expandFont = function* (value2) {
-  const [fontStyle, fontVariant, fontWeight, fontWidth, config] = parseUnordered(
+  const [fontStyle2, fontVariant, fontWeight, fontWidth, config] = parseUnordered(
     [
       "<'font-style'>",
       "<font-variant-css21>",
@@ -118224,7 +118158,7 @@ const expandFont = function* (value2) {
       fontFamily = createValueNode(fontFamilyNodes);
     }
   }
-  yield ["font-style", fontStyle ?? createInitialNode()];
+  yield ["font-style", fontStyle2 ?? createInitialNode()];
   yield ["font-variant-caps", fontVariant ?? createInitialNode()];
   yield ["font-weight", fontWeight ?? createInitialNode()];
   yield ["font-stretch", fontWidth ?? createInitialNode()];
@@ -148088,20 +148022,20 @@ const renderTemplate = (root2, generateId, initialBreakpoints = [], options = {}
     assets: []
   };
 };
-const createProxy = (prefix) => {
+const createProxy = (prefix, transformName = (name2) => name2) => {
   return new Proxy(
     {},
     {
       get(_target, prop2) {
         const component = () => void 0;
-        component.displayName = `${prefix}${prop2}`;
+        component.displayName = `${prefix}${transformName(String(prop2))}`;
         return component;
       }
     }
   );
 };
 const $$3 = createProxy("");
-const ws = createProxy("ws:");
+const ws = createProxy("ws:", kebabCase);
 var jsxRuntime = { exports: {} };
 var reactJsxRuntime_production_min = {};
 var hasRequiredReactJsxRuntime_production_min;
@@ -209235,8 +209169,8 @@ function _matchesScope(scopeName, scopePattern) {
   return scopePattern === scopeName || scopeName.startsWith(scopePattern) && scopeName[scopePattern.length] === ".";
 }
 var StyleAttributes = class {
-  constructor(fontStyle, foregroundId, backgroundId) {
-    this.fontStyle = fontStyle;
+  constructor(fontStyle2, foregroundId, backgroundId) {
+    this.fontStyle = fontStyle2;
     this.foregroundId = foregroundId;
     this.backgroundId = backgroundId;
   }
@@ -209266,24 +209200,24 @@ function parseTheme(source) {
     } else {
       scopes = [""];
     }
-    let fontStyle = -1;
+    let fontStyle2 = -1;
     if (typeof entry2.settings.fontStyle === "string") {
-      fontStyle = 0;
+      fontStyle2 = 0;
       let segments = entry2.settings.fontStyle.split(" ");
       for (let j2 = 0, lenJ = segments.length; j2 < lenJ; j2++) {
         let segment = segments[j2];
         switch (segment) {
           case "italic":
-            fontStyle = fontStyle | 1;
+            fontStyle2 = fontStyle2 | 1;
             break;
           case "bold":
-            fontStyle = fontStyle | 2;
+            fontStyle2 = fontStyle2 | 2;
             break;
           case "underline":
-            fontStyle = fontStyle | 4;
+            fontStyle2 = fontStyle2 | 4;
             break;
           case "strikethrough":
-            fontStyle = fontStyle | 8;
+            fontStyle2 = fontStyle2 | 8;
             break;
         }
       }
@@ -209309,7 +209243,7 @@ function parseTheme(source) {
         scope2,
         parentScopes,
         i,
-        fontStyle,
+        fontStyle2,
         foreground,
         background
       );
@@ -209318,11 +209252,11 @@ function parseTheme(source) {
   return result2;
 }
 var ParsedThemeRule = class {
-  constructor(scope2, parentScopes, index2, fontStyle, foreground, background) {
+  constructor(scope2, parentScopes, index2, fontStyle2, foreground, background) {
     this.scope = scope2;
     this.parentScopes = parentScopes;
     this.index = index2;
-    this.fontStyle = fontStyle;
+    this.fontStyle = fontStyle2;
     this.foreground = foreground;
     this.background = background;
   }
@@ -209419,10 +209353,10 @@ var ThemeTrieElementRule = class _ThemeTrieElementRule {
   fontStyle;
   foreground;
   background;
-  constructor(scopeDepth, parentScopes, fontStyle, foreground, background) {
+  constructor(scopeDepth, parentScopes, fontStyle2, foreground, background) {
     this.scopeDepth = scopeDepth;
     this.parentScopes = parentScopes || emptyParentScopes;
-    this.fontStyle = fontStyle;
+    this.fontStyle = fontStyle2;
     this.foreground = foreground;
     this.background = background;
   }
@@ -209436,14 +209370,14 @@ var ThemeTrieElementRule = class _ThemeTrieElementRule {
     }
     return r2;
   }
-  acceptOverwrite(scopeDepth, fontStyle, foreground, background) {
+  acceptOverwrite(scopeDepth, fontStyle2, foreground, background) {
     if (this.scopeDepth > scopeDepth) {
       console.log("how did this happen?");
     } else {
       this.scopeDepth = scopeDepth;
     }
-    if (fontStyle !== -1) {
-      this.fontStyle = fontStyle;
+    if (fontStyle2 !== -1) {
+      this.fontStyle = fontStyle2;
     }
     if (foreground !== 0) {
       this.foreground = foreground;
@@ -209505,9 +209439,9 @@ var ThemeTrieElement = class _ThemeTrieElement {
     rules.sort(_ThemeTrieElement._cmpBySpecificity);
     return rules;
   }
-  insert(scopeDepth, scope2, parentScopes, fontStyle, foreground, background) {
+  insert(scopeDepth, scope2, parentScopes, fontStyle2, foreground, background) {
     if (scope2 === "") {
-      this._doInsertHere(scopeDepth, parentScopes, fontStyle, foreground, background);
+      this._doInsertHere(scopeDepth, parentScopes, fontStyle2, foreground, background);
       return;
     }
     let dotIndex = scope2.indexOf(".");
@@ -209527,22 +209461,22 @@ var ThemeTrieElement = class _ThemeTrieElement {
       child = new _ThemeTrieElement(this._mainRule.clone(), ThemeTrieElementRule.cloneArr(this._rulesWithParentScopes));
       this._children[head2] = child;
     }
-    child.insert(scopeDepth + 1, tail, parentScopes, fontStyle, foreground, background);
+    child.insert(scopeDepth + 1, tail, parentScopes, fontStyle2, foreground, background);
   }
-  _doInsertHere(scopeDepth, parentScopes, fontStyle, foreground, background) {
+  _doInsertHere(scopeDepth, parentScopes, fontStyle2, foreground, background) {
     if (parentScopes === null) {
-      this._mainRule.acceptOverwrite(scopeDepth, fontStyle, foreground, background);
+      this._mainRule.acceptOverwrite(scopeDepth, fontStyle2, foreground, background);
       return;
     }
     for (let i = 0, len = this._rulesWithParentScopes.length; i < len; i++) {
       let rule2 = this._rulesWithParentScopes[i];
       if (strArrCmp(rule2.parentScopes, parentScopes) === 0) {
-        rule2.acceptOverwrite(scopeDepth, fontStyle, foreground, background);
+        rule2.acceptOverwrite(scopeDepth, fontStyle2, foreground, background);
         return;
       }
     }
-    if (fontStyle === -1) {
-      fontStyle = this._mainRule.fontStyle;
+    if (fontStyle2 === -1) {
+      fontStyle2 = this._mainRule.fontStyle;
     }
     if (foreground === 0) {
       foreground = this._mainRule.foreground;
@@ -209550,7 +209484,7 @@ var ThemeTrieElement = class _ThemeTrieElement {
     if (background === 0) {
       background = this._mainRule.background;
     }
-    this._rulesWithParentScopes.push(new ThemeTrieElementRule(scopeDepth, parentScopes, fontStyle, foreground, background));
+    this._rulesWithParentScopes.push(new ThemeTrieElementRule(scopeDepth, parentScopes, fontStyle2, foreground, background));
   }
 };
 var EncodedTokenMetadata = class _EncodedTokenMetadata {
@@ -209560,13 +209494,13 @@ var EncodedTokenMetadata = class _EncodedTokenMetadata {
   static print(encodedTokenAttributes) {
     const languageId = _EncodedTokenMetadata.getLanguageId(encodedTokenAttributes);
     const tokenType2 = _EncodedTokenMetadata.getTokenType(encodedTokenAttributes);
-    const fontStyle = _EncodedTokenMetadata.getFontStyle(encodedTokenAttributes);
+    const fontStyle2 = _EncodedTokenMetadata.getFontStyle(encodedTokenAttributes);
     const foreground = _EncodedTokenMetadata.getForeground(encodedTokenAttributes);
     const background = _EncodedTokenMetadata.getBackground(encodedTokenAttributes);
     console.log({
       languageId,
       tokenType: tokenType2,
-      fontStyle,
+      fontStyle: fontStyle2,
       foreground,
       background
     });
@@ -209593,7 +209527,7 @@ var EncodedTokenMetadata = class _EncodedTokenMetadata {
    * Updates the fields in `metadata`.
    * A value of `0`, `NotSet` or `null` indicates that the corresponding field should be left as is.
    */
-  static set(encodedTokenAttributes, languageId, tokenType2, containsBalancedBrackets, fontStyle, foreground, background) {
+  static set(encodedTokenAttributes, languageId, tokenType2, containsBalancedBrackets, fontStyle2, foreground, background) {
     let _languageId = _EncodedTokenMetadata.getLanguageId(encodedTokenAttributes);
     let _tokenType = _EncodedTokenMetadata.getTokenType(encodedTokenAttributes);
     let _containsBalancedBracketsBit = _EncodedTokenMetadata.containsBalancedBrackets(encodedTokenAttributes) ? 1 : 0;
@@ -209609,8 +209543,8 @@ var EncodedTokenMetadata = class _EncodedTokenMetadata {
     if (containsBalancedBrackets !== null) {
       _containsBalancedBracketsBit = containsBalancedBrackets ? 1 : 0;
     }
-    if (fontStyle !== -1) {
-      _fontStyle = fontStyle;
+    if (fontStyle2 !== -1) {
+      _fontStyle = fontStyle2;
     }
     if (foreground !== 0) {
       _foreground = foreground;
@@ -211472,11 +211406,11 @@ var AttributedScopeStack = class _AttributedScopeStack {
     } while (true);
   }
   static mergeAttributes(existingTokenAttributes, basicScopeAttributes, styleAttributes) {
-    let fontStyle = -1;
+    let fontStyle2 = -1;
     let foreground = 0;
     let background = 0;
     if (styleAttributes !== null) {
-      fontStyle = styleAttributes.fontStyle;
+      fontStyle2 = styleAttributes.fontStyle;
       foreground = styleAttributes.foregroundId;
       background = styleAttributes.backgroundId;
     }
@@ -211485,7 +211419,7 @@ var AttributedScopeStack = class _AttributedScopeStack {
       basicScopeAttributes.languageId,
       basicScopeAttributes.tokenType,
       null,
-      fontStyle,
+      fontStyle2,
       foreground,
       background
     );
@@ -212605,12 +212539,12 @@ function _tokenizeWithTheme(code2, grammar, theme, colorMap, options) {
       if (startIndex === nextStartIndex) continue;
       const metadata = result2.tokens[2 * j2 + 1];
       const color2 = applyColorReplacements(colorMap[EncodedTokenMetadata.getForeground(metadata)], colorReplacements);
-      const fontStyle = EncodedTokenMetadata.getFontStyle(metadata);
+      const fontStyle2 = EncodedTokenMetadata.getFontStyle(metadata);
       const token2 = {
         content: line.substring(startIndex, nextStartIndex),
         offset: lineOffset + startIndex,
         color: color2,
-        fontStyle
+        fontStyle: fontStyle2
       };
       if (includeExplanation === "tokenType") token2.type = EncodedTokenMetadata.getTokenType(metadata);
       else if (includeExplanation) {
@@ -214217,17 +214151,17 @@ function tokenizeAnsiWithTheme(theme, fileContents, options) {
     color2 = applyColorReplacements(color2, colorReplacements);
     bgColor = applyColorReplacements(bgColor, colorReplacements);
     if (token2.decorations.has("dim")) color2 = dimColor(color2);
-    let fontStyle = FontStyle.None;
-    if (token2.decorations.has("bold")) fontStyle |= FontStyle.Bold;
-    if (token2.decorations.has("italic")) fontStyle |= FontStyle.Italic;
-    if (token2.decorations.has("underline")) fontStyle |= FontStyle.Underline;
-    if (token2.decorations.has("strikethrough")) fontStyle |= FontStyle.Strikethrough;
+    let fontStyle2 = FontStyle.None;
+    if (token2.decorations.has("bold")) fontStyle2 |= FontStyle.Bold;
+    if (token2.decorations.has("italic")) fontStyle2 |= FontStyle.Italic;
+    if (token2.decorations.has("underline")) fontStyle2 |= FontStyle.Underline;
+    if (token2.decorations.has("strikethrough")) fontStyle2 |= FontStyle.Strikethrough;
     return {
       content: token2.value,
       offset: line[1],
       color: color2,
       bgColor,
-      fontStyle
+      fontStyle: fontStyle2
     };
   }));
 }
@@ -229680,7 +229614,9 @@ const findPageAndSelectorByInstanceId = (pages2, instances, startingInstanceId)
   }
   return { pageId: pages2.homePageId, instanceSelector };
 };
-const conflictResolutionInput = z$4.enum(["ours", "theirs", "merge"]);
+const conflictResolutionInput = z$4.enum(["ours", "theirs", "merge"]).describe(
+  'How to resolve incoming design tokens that share a name with an existing token. "ours" keeps the existing token styles and id, "theirs" uses incoming styles, and "merge" combines both.'
+);
 const insertComponentInput = z$4.object({
   parentInstanceId: z$4.string(),
   component: instanceComponent.describe(
@@ -229696,7 +229632,9 @@ const insertFragmentInput = z$4.object({
     "Structured Webstudio fragment produced by Webstudio JSX/template helpers. Runtime remaps fragment ids to generated project ids."
   ),
   conflictResolution: conflictResolutionInput.optional(),
-  contentMode: z$4.boolean().optional(),
+  contentMode: z$4.boolean().optional().describe(
+    "Apply content-mode copy restrictions to props and styles while reusing existing tokens and breakpoints."
+  ),
   mode: instanceInsertModeInput.optional(),
   insertIndex: insertIndexInput.optional()
 }).superRefine((input2, context) => {
@@ -247617,11 +247555,71 @@ const errorDiagnostic = (error) => {
     details: redactProjectSessionValue(error)
   };
 };
+const getCommitConfirmationFailureCode = (error) => {
+  if (typeof error !== "object" || error === null || !("confirmationFailure" in error)) {
+    return;
+  }
+  const failure = error.confirmationFailure;
+  if (typeof failure !== "object" || failure === null || !("code" in failure) || typeof failure.code !== "string") {
+    return;
+  }
+  return failure.code;
+};
+const isAuthorizationErrorCode = (code2) => code2 === "UNAUTHORIZED" || code2 === "FORBIDDEN" || code2 === "PLAN_REQUIRED";
 const shouldRefreshPermissionsAfterError = (error) => {
-  const code2 = getProjectSessionErrorCode(error);
-  return code2 === "UNAUTHORIZED" || code2 === "FORBIDDEN" || code2 === "PLAN_REQUIRED";
+  return isAuthorizationErrorCode(getProjectSessionErrorCode(error)) || isAuthorizationErrorCode(getCommitConfirmationFailureCode(error));
 };
 const isVersionConflictError = (error) => getProjectSessionErrorCode(error) === "CONFLICT";
+const createCommitConfirmationConflictError = ({
+  conflictError,
+  confirmationError
+}) => Object.assign(
+  new Error(
+    conflictError instanceof Error ? conflictError.message : "Build version conflict",
+    { cause: confirmationError }
+  ),
+  {
+    code: "CONFLICT",
+    confirmationFailure: {
+      code: getProjectSessionErrorCode(confirmationError),
+      message: confirmationError instanceof Error ? confirmationError.message : "Unknown error"
+    }
+  }
+);
+const commitWithConflictConfirmation = async ({
+  commit,
+  input: input2
+}) => {
+  try {
+    return {
+      result: await commit(input2),
+      confirmedAfterRetry: false
+    };
+  } catch (conflictError) {
+    if (isVersionConflictError(conflictError) === false) {
+      throw conflictError;
+    }
+    try {
+      return {
+        result: await commit(input2),
+        confirmedAfterRetry: true
+      };
+    } catch (confirmationError) {
+      if (isVersionConflictError(confirmationError)) {
+        throw confirmationError;
+      }
+      throw createCommitConfirmationConflictError({
+        conflictError,
+        confirmationError
+      });
+    }
+  }
+};
+const commitRetryConfirmedDiagnostic = {
+  level: "info",
+  code: "COMMIT_RETRY_CONFIRMED",
+  message: "The transaction was confirmed committed after retrying the same transaction ID."
+};
 const isProjectSessionBusyError = (error) => getProjectSessionErrorCode(error) === "PROJECT_SESSION_BUSY";
 const createProjectSessionBusyError = (cause) => new ProjectSessionBusyError({ cause });
 const hasProjectSessionPermit = (permissions, permit) => {
@@ -247822,12 +247820,16 @@ class ProjectSession {
           transaction
         });
       }
-      const commit = await this.#options.transport.commitRestorePoint({
-        projectId: snapshot.projectId,
-        buildId: snapshot.buildId,
-        baseVersion: snapshot.version,
-        transactions: [transaction]
+      const { result: commit, confirmedAfterRetry } = await commitWithConflictConfirmation({
+        commit: (input2) => this.#options.transport.commitRestorePoint(input2),
+        input: {
+          projectId: snapshot.projectId,
+          buildId: snapshot.buildId,
+          baseVersion: snapshot.version,
+          transactions: [transaction]
+        }
       });
+      const diagnostics = confirmedAfterRetry ? [commitRetryConfirmedDiagnostic] : [];
       const applied = applyBuilderPatchTransactions(snapshot.state, [
         transaction
       ]);
@@ -247847,7 +247849,7 @@ class ProjectSession {
       const persisted = await this.#synchronizeAfterCommit({
         snapshot: committedSnapshot,
         namespaces: restorePointNamespaces,
-        diagnostics: []
+        diagnostics
       });
       return this.createEnvelope({
         source: "local",
@@ -248128,7 +248130,7 @@ class ProjectSession {
             code: "CONFLICT_REFRESHED",
             message: "Remote build changed. Required namespaces were refreshed; rerun the operation against the latest snapshot."
           });
-          if (contract.retryOnConflict && options.dryRun !== true) {
+          if (contract.retryOnConflict && options.dryRun !== true && getCommitConfirmationFailureCode(error) === void 0) {
             return await this.commitMutation({
               operationId,
               input: input2,
@@ -248219,12 +248221,17 @@ class ProjectSession {
         input2
       );
     }
-    const commit = await this.#options.transport.commitPatch({
+    const commitInput = {
       projectId: snapshot.projectId,
       buildId: snapshot.buildId,
       baseVersion: snapshot.version,
       transactions: [transaction]
+    };
+    const { result: commit, confirmedAfterRetry } = await commitWithConflictConfirmation({
+      commit: (input22) => this.#options.transport.commitPatch(input22),
+      input: commitInput
     });
+    const commitDiagnostics = confirmedAfterRetry ? [...diagnostics, commitRetryConfirmedDiagnostic] : diagnostics;
     const applied = applyBuilderPatchTransactions(snapshot.state, [
       transaction
     ]);
@@ -248256,7 +248263,7 @@ class ProjectSession {
         contract.writeNamespaces,
         mutation.invalidatesNamespaces
       ),
-      diagnostics
+      diagnostics: commitDiagnostics
     });
     return this.createEnvelope({
       source: "local",
@@ -253868,6 +253875,7 @@ const screenshotWaitUntilValues = [
 const defaultScreenshotWaitUntil = "load";
 const defaultScreenshotWaitForTimeout = 250;
 const defaultScreenshotTimeout = 3e4;
+const defaultBrowserStartupTimeout = 1e4;
 const isScreenshotWaitUntil = (value2) => typeof value2 === "string" && screenshotWaitUntilValues.includes(value2);
 const withTimeout$1 = async (operation, timeout, createTimeoutError2) => {
   let timeoutId;
@@ -254650,6 +254658,13 @@ const getScreenshotCaptureParams = async ({
     }
   };
 };
+class BrowserStartupError extends Error {
+  code = "BROWSER_STARTUP_FAILED";
+  constructor(message, options) {
+    super(message, options);
+    this.name = "BrowserStartupError";
+  }
+}
 class BrowserSessionClosedError extends Error {
 }
 const getBrowserExitMessage = (message, reason) => `${message}${reason === void 0 ? "" : ` (${reason})`}. Check the browser installation or provide a supported Chromium executable.`;
@@ -254680,6 +254695,7 @@ const stopBrowserProcess = async ({
   ).catch(() => void 0);
 };
 const startBrowserRuntimeOnce = async (options, dependencies2) => {
+  const startupTimeout = options.startupTimeout ?? options.timeout;
   const userDataDir = await dependencies2.mkdtemp(
     join$1(tmpdir(), "vision-browser-")
   );
@@ -254718,7 +254734,7 @@ const startBrowserRuntimeOnce = async (options, dependencies2) => {
   });
   try {
     const { port } = await Promise.race([
-      waitForDevToolsPort(userDataDir, dependencies2, options.timeout),
+      waitForDevToolsPort(userDataDir, dependencies2, startupTimeout),
       browserClosed.then((reason) => {
         throw new BrowserSessionClosedError(
           getBrowserExitMessage(
@@ -254759,7 +254775,7 @@ const startBrowserRuntimeOnce = async (options, dependencies2) => {
       browserProcess,
       browserClosed,
       running,
-      gracePeriodMs: Math.min(options.timeout, 2e3)
+      gracePeriodMs: Math.min(startupTimeout, 2e3)
     });
     await dependencies2.rm(userDataDir, { recursive: true, force: true }).catch(() => void 0);
     throw error;
@@ -254770,10 +254786,20 @@ const startBrowserRuntime = async (options, dependencies2) => {
     return await startBrowserRuntimeOnce(options, dependencies2);
   } catch (error) {
     if (error instanceof BrowserSessionClosedError === false) {
-      throw error;
+      throw new BrowserStartupError(
+        error instanceof Error ? error.message : String(error),
+        { cause: error }
+      );
     }
   }
-  return await startBrowserRuntimeOnce(options, dependencies2);
+  try {
+    return await startBrowserRuntimeOnce(options, dependencies2);
+  } catch (error) {
+    throw new BrowserStartupError(
+      error instanceof Error ? error.message : String(error),
+      { cause: error }
+    );
+  }
 };
 const capturePageWithBrowserRuntime = async (runtime, optionsList, dependencies2) => {
   const firstOptions = optionsList[0];
@@ -257045,43 +257071,6 @@ const workflowNextInputSchema = {
   },
   required: []
 };
-const insertFragmentMcpInputSchema = {
-  ...emptyInputSchema,
-  description: "Insert a Webstudio fragment from a Webstudio JSX string. The CLI converts JSX into structured Webstudio data before mutation.",
-  additionalProperties: false,
-  properties: {
-    parentInstanceId: {
-      type: "string",
-      description: "Parent instance id where the fragment is inserted."
-    },
-    fragment: {
-      type: "string",
-      description: webstudioJsxFragmentInputDescription
-    },
-    mode: {
-      type: "string",
-      enum: ["append", "prepend", "replace"],
-      description: "Append, prepend, or replace parent children before inserting the fragment."
-    },
-    insertIndex: {
-      type: "number",
-      description: "Zero-based child index for insertion."
-    }
-  },
-  required: ["parentInstanceId", "fragment"]
-};
-const insertFragmentVerifiedMcpInputSchema = {
-  ...insertFragmentMcpInputSchema,
-  description: "Insert a Webstudio fragment and immediately verify its persisted bindings in one call.",
-  properties: {
-    ...insertFragmentMcpInputSchema.properties,
-    pagePath: {
-      type: "string",
-      description: "Concrete page path used for post-commit binding verification, for example /account."
-    }
-  },
-  required: ["parentInstanceId", "fragment", "pagePath"]
-};
 const insertCollectionMcpInput = insertCollectionInput.omit({ itemFragment: true }).extend({
   itemFragment: z$4.string().describe(
     `${webstudioJsxFragmentInputDescription} Pass exactly one root instance. Expressions may reference collectionItem and collectionItemKey, for example {expression\`collectionItem.name\`}.`
@@ -257261,6 +257250,26 @@ const getZodObjectSchema = (schema2) => {
   };
 };
 const getZodMcpInputSchema = (schema2) => getHandshakeInputSchema(getZodObjectSchema(schema2)).inputSchema;
+const insertFragmentMcpInput = z$4.object({
+  ...insertFragmentInput.shape,
+  parentInstanceId: insertFragmentInput.shape.parentInstanceId.unwrap().describe("Parent instance id where the fragment is inserted."),
+  fragment: z$4.string().describe(webstudioJsxFragmentInputDescription)
+}).describe(
+  "Insert a Webstudio fragment from a Webstudio JSX string. The CLI converts JSX into structured Webstudio data before mutation."
+);
+const insertFragmentMcpInputSchema = getZodObjectSchema(insertFragmentMcpInput);
+const insertFragmentVerifiedMcpInputSchema = {
+  ...insertFragmentMcpInputSchema,
+  description: "Insert a Webstudio fragment and immediately verify its persisted bindings in one call.",
+  properties: {
+    ...insertFragmentMcpInputSchema.properties,
+    pagePath: {
+      type: "string",
+      description: "Concrete page path used for post-commit binding verification, for example /account."
+    }
+  },
+  required: ["parentInstanceId", "fragment", "pagePath"]
+};
 const insertCollectionMcpInputSchema = getOperationInputSchema({
   inputSchema: getInputSchemaMetadata(insertCollectionMcpInput).inputJsonSchema
 });
@@ -257884,6 +257893,19 @@ const previewInputSchema = {
       type: "array",
       description: "External image hostnames allowed by the generated preview optimizer, for example storage.example.com.",
       items: { type: "string" }
+    },
+    maxDurationMs: {
+      type: "integer",
+      minimum: 1,
+      description: "Maximum acceptable duration. Slow work returns a confirmation preflight instead of starting when it cannot reasonably fit this budget."
+    },
+    confirmSlow: {
+      type: "boolean",
+      description: "Must be true after explicit user consent for the unchanged slow-operation preflight."
+    },
+    confirmationToken: {
+      type: "string",
+      description: "Short-lived token returned by the unchanged slow-operation preflight."
     }
   }
 };
@@ -258718,7 +258740,25 @@ const previewStatusDataSchema = {
 };
 const previewDataSchema = {
   ...previewStatusDataSchema,
-  required: ["url", "running", "mode"]
+  properties: {
+    ...previewStatusDataSchema.properties,
+    confirmationRequired: { type: "boolean" },
+    operation: { type: "string" },
+    estimatedDuration: { type: "string" },
+    reason: { type: "string" },
+    confirmationToken: { type: "string" },
+    fasterAlternative: {
+      type: "object",
+      properties: {
+        operation: { type: "string" },
+        estimatedDuration: { type: "string" },
+        limitations: { type: "string" }
+      },
+      required: ["operation", "estimatedDuration", "limitations"],
+      additionalProperties: false
+    }
+  },
+  required: ["running", "mode"]
 };
 const restorePointSummaryDataSchema = getZodObjectSchema(
   projectSessionRestorePointSummarySchema
@@ -259531,11 +259571,12 @@ const hiddenMcpOperationCommands = /* @__PURE__ */ new Set([
   // MCP callers use duplicate-page or serializable page-transfer workflows.
   "copy-page"
 ]);
-const compactMcpOperationCommands = /* @__PURE__ */ new Set([
-  "create-assets-resource",
-  "update-assets-resource",
-  "validate-asset-query",
-  "preview-asset-query"
+const mcpOperationSchemaInlineSizes = /* @__PURE__ */ new Map([
+  ["insert-fragment", 1e3],
+  ["create-assets-resource", 2500],
+  ["update-assets-resource", 2500],
+  ["validate-asset-query", 2500],
+  ["preview-asset-query", 2500]
 ]);
 const detailedMcpInputSchemas = /* @__PURE__ */ new WeakMap();
 const getDetailedProjectSessionMcpInputSchema = (tool) => detailedMcpInputSchemas.get(tool) ?? tool.inputSchema;
@@ -259550,7 +259591,7 @@ const listProjectSessionMcpTools = (operations, options = {}) => [
     });
     const { inputSchema, detailedInputSchema } = getHandshakeInputSchema(
       operationInputSchema,
-      compactMcpOperationCommands.has(operation.command) ? 2500 : void 0
+      mcpOperationSchemaInlineSizes.get(operation.command)
     );
     const tool = createProjectSessionMcpTool({
       name: operation.command,
@@ -259919,23 +259960,11 @@ const getInsertFragmentInput = async (input2) => {
       `insert-fragment requires fragment as a Webstudio JSX string, for example {"fragment":"<ws.element ws:tag='section' />"}.`
     );
   }
-  const fragment = await parseWebstudioJsxFragment(input2.fragment);
-  const mode = input2.mode;
-  if (mode !== void 0 && mode !== "append" && mode !== "prepend" && mode !== "replace") {
-    throw new Error(
-      'insert-fragment mode must be "append", "prepend", or "replace".'
-    );
-  }
-  const insertIndex = input2.insertIndex;
-  if (insertIndex !== void 0 && typeof insertIndex !== "number") {
-    throw new Error("insert-fragment insertIndex must be a number.");
-  }
-  return {
-    parentInstanceId: input2.parentInstanceId,
-    fragment,
-    mode,
-    insertIndex
-  };
+  const { fragment: fragmentSource, ...runtimeInput } = insertFragmentMcpInput.parse(input2);
+  return insertFragmentInput.parse({
+    ...runtimeInput,
+    fragment: await parseWebstudioJsxFragment(fragmentSource)
+  });
 };
 const getInsertCollectionInput = async (input2) => {
   const { itemFragment, ...parsedInput } = insertCollectionMcpInput.parse(input2);
@@ -260320,7 +260349,7 @@ const filterCapabilities = (tools) => {
   return capabilities;
 };
 const startupGuidance = [
-  "For any multi-step authoring task, first call meta.guide with the user's objective and follow its complete workflow, including final audit, preview, and screenshot steps.",
+  "For any multi-step authoring task, first call meta.guide with the user's objective and follow its proportional workflow. Small corrections stop after focused assertions; preview and screenshots are required only when the requested outcome is visual or runtime-dependent.",
   "Mutation responses can include meta.next. Treat those steps as required before reporting completion.",
   "Every local-capable mutation exposes dryRun. Destructive delete, replace, and replace-all calls plan first; review the transaction, ask the user to confirm, then retry the unchanged call with confirmDestructive: true and meta.confirmation.token. Never retry blindly because changed input, version, or plan invalidates the short-lived token.",
   readProjectBuildDoc("mcp-startup-guidance").trim()
@@ -260468,7 +260497,8 @@ const getComponentSummaryEntry = ({
   }
   const [parsedNamespace, exportName] = parseComponentName(component);
   const namespace2 = parsedNamespace ?? "global";
-  const jsxNamespace = parsedNamespace === "@webstudio-is/sdk-components-react-radix" ? "radix" : parsedNamespace === "@webstudio-is/sdk-components-animation" ? "animation" : "$";
+  const jsxNamespace = parsedNamespace === radixComponentNamespace ? "radix" : parsedNamespace === animationComponentNamespace ? "animation" : parsedNamespace === "ws" ? "ws" : "$";
+  const jsxExportName = parsedNamespace === "ws" ? camelCase(exportName) : exportName;
   const template = templateMeta?.template;
   const hasTemplate = template !== void 0;
   const instancesById = new Map(
@@ -260507,7 +260537,7 @@ const getComponentSummaryEntry = ({
     component,
     exportName,
     namespace: namespace2,
-    jsxElement: `<${jsxNamespace}.${exportName} />`,
+    jsxElement: `<${jsxNamespace}.${jsxExportName} />`,
     label: meta2.label,
     category: visibleCategory,
     contentCategory: meta2.contentModel?.category,
@@ -261500,6 +261530,29 @@ const metaGoalGuides = [
 ];
 const metaGuideDetailedInputSchemaTools = /* @__PURE__ */ new Set(["update-styles"]);
 const metaGuideExampleTools = /* @__PURE__ */ new Set(["upload-assets"]);
+const classifyTaskScope = (brief) => {
+  if (/\b(project[- ]wide|site[- ]wide|all pages|every page|migration|migrate)\b/i.test(
+    brief
+  )) {
+    return "project-wide-migration";
+  }
+  if (/\b(visual|layout|responsive|screenshot|typography|spacing|color|design)\b/i.test(
+    brief
+  )) {
+    return "visual-change";
+  }
+  if (/\b(create|insert|delete|remove|move|wrap|unwrap|duplicate|reparent)\b.*\b(page|section|component|instance|element|tree|folder)\b/i.test(
+    brief
+  )) {
+    return "structural-project-change";
+  }
+  if (/\b(correct|correction|fix|replace|update|change|typo)\b.*\b(value|text|copy|reference|asset|url|link|title|description|metadata|prop|binding)\b/i.test(
+    brief
+  )) {
+    return "small-value-or-reference-correction";
+  }
+  return "focused-page-change";
+};
 const serializeMetaGuideTool = (tool, includeHandshakeFields) => includeHandshakeFields ? {
   name: tool.name,
   use: tool.description,
@@ -261515,13 +261568,17 @@ const serializeMetaGuideTool = (tool, includeHandshakeFields) => includeHandshak
   ...metaGuideDetailedInputSchemaTools.has(tool.name) ? { inputSchema: getDetailedProjectSessionMcpInputSchema(tool) } : {}
 };
 const getMetaGuide = (brief, tools, guidance) => {
+  const taskScope = classifyTaskScope(brief);
   const goalGuide = metaGoalGuides.find(({ pattern }) => pattern.test(brief));
   const matches2 = goalGuide === void 0 ? getMatchingTools(brief, tools).slice(0, 12) : getExactToolSelection(goalGuide.tools, tools).tools;
   const canVerifyVisually = tools.some((tool) => tool.name === "preview.start") && tools.some((tool) => tool.name === "screenshot");
   const canDiffScreenshots = tools.some(
     (tool) => tool.name === "screenshot.diff"
   );
+  const isSmallCorrection = taskScope === "small-value-or-reference-correction";
+  const needsVisualVerification = taskScope === "visual-change";
   const generalWorkflow = [
+    isSmallCorrection ? "Focused search → atomic edit → targeted assertions." : void 0,
     "Use the fewest discovery calls needed for the immediate action.",
     "Call permissions or status only when the task depends on capabilities or local session freshness.",
     matches2.some((tool) => tool.annotations.localCapable) && matches2.some((tool) => tool.name === "verify-font-assets") === false ? "Call refresh if cached namespaces may be stale." : void 0,
@@ -261529,11 +261586,26 @@ const getMetaGuide = (brief, tools, guidance) => {
     "Use the smallest semantic mutation tool that matches the requested change.",
     valuesVsBindingsRule,
     "Use apply-patch only when no semantic mutation tool fits.",
-    canVerifyVisually && guidance !== void 0 ? guidance.getVisionWorkflowSummary({ includeDiff: canDiffScreenshots }) : void 0
+    needsVisualVerification && canVerifyVisually && guidance !== void 0 ? guidance.getVisionWorkflowSummary({ includeDiff: canDiffScreenshots }) : void 0
   ].filter(Boolean);
   return {
+    taskScope,
     delegatedAgentRule: "Do not spend the whole phase on discovery. If you are delegated/non-streaming and the parent asks for status within 30 seconds, run exactly one shortcut command such as webstudio meta.index or one explicit webstudio mcp single-op-call command, report its command/result, and wait before the next MCP command.",
     workflow: goalGuide?.workflow ?? generalWorkflow,
+    visionLoop: needsVisualVerification && canVerifyVisually && guidance !== void 0 ? guidance.getVisionVerificationLoop({
+      includeDiff: canDiffScreenshots
+    }) : [],
+    slowOperation: {
+      confirmationRequired: true,
+      operation: "full production preview",
+      estimatedDuration: "30–60 seconds",
+      reason: "Builds complete rendered output and is unnecessary for a focused value correction unless the requested outcome depends on layout or runtime behavior.",
+      fasterAlternative: {
+        operation: "targeted route validation",
+        estimatedDuration: "2–5 seconds",
+        limitations: "Does not visually inspect layout."
+      }
+    },
     tools: matches2.map(
       (tool) => serializeMetaGuideTool(tool, goalGuide === void 0)
     ),
@@ -262386,6 +262458,43 @@ const getPreviewInput = (input2) => {
     imageDomains
   };
 };
+const slowOperationConfirmationTtlMs = 5 * 60 * 1e3;
+const getProductionPreviewPreflight = async (input2) => {
+  if (isRecord(input2) === false || input2.mode !== "production") {
+    return;
+  }
+  const previewInput = getPreviewInput(input2);
+  const confirmationPayload = {
+    operation: "production preview build",
+    input: previewInput,
+    maxDurationMs: typeof input2.maxDurationMs === "number" ? input2.maxDurationMs : void 0
+  };
+  if (input2.confirmSlow === true && await validateConfirmationToken(
+    typeof input2.confirmationToken === "string" ? input2.confirmationToken : void 0,
+    confirmationPayload
+  )) {
+    return;
+  }
+  const { token: token2 } = await createConfirmationToken(
+    confirmationPayload,
+    slowOperationConfirmationTtlMs
+  );
+  const maxDurationMs = typeof input2.maxDurationMs === "number" ? input2.maxDurationMs : void 0;
+  return {
+    running: false,
+    mode: "production",
+    confirmationRequired: true,
+    operation: "production preview build",
+    estimatedDuration: "30–60 seconds",
+    reason: maxDurationMs !== void 0 && maxDurationMs < 3e4 ? `A full production preview cannot reasonably finish within the ${maxDurationMs}ms budget.` : "A full production preview builds complete rendered output and is expected to exceed 10 seconds.",
+    confirmationToken: token2,
+    fasterAlternative: {
+      operation: "targeted route validation",
+      estimatedDuration: "2–5 seconds",
+      limitations: "Does not visually inspect layout."
+    }
+  };
+};
 const getImportInput = (input2) => {
   if (isRecord(input2) === false) {
     throw new Error("import input must be an object.");
@@ -262947,6 +263056,10 @@ const createProjectSessionMcpCore = ({
         return toMetaResult(await installOcr());
       }
       if (name2 === "preview.start" && startPreview !== void 0) {
+        const preflight = await getProductionPreviewPreflight(input2);
+        if (preflight !== void 0) {
+          return toMetaResult(preflight);
+        }
         return toMetaResult(
           await startPreview(getPreviewInput(input2), {
             report: (message) => {
@@ -263200,9 +263313,9 @@ const createProjectSessionMcpCore = ({
           "After changing props, variables, or resources, run verify-bindings for the changed page or instance and resolve every finding."
         ] : [],
         ...needsVisualVerification ? [
-          "Before reporting completion, run audit for the changed page or project.",
+          "For a small fixed-value or reference correction, re-read the changed value and run only relevant focused assertions; stop when they pass. Run audit when the change is structural or broader.",
           ...startPreview !== void 0 && captureScreenshot2 !== void 0 ? [
-            "For visual changes, start a session preview and capture desktop and mobile screenshots before reporting completion."
+            "Only when the requested outcome is visual or runtime-dependent, start a session preview and capture the necessary screenshots. Production preview requires a slow-operation preflight and explicit confirmation."
           ] : []
         ] : []
       ];
@@ -267951,7 +268064,7 @@ class HandledCliError extends Error {
 }
 const isHandledCliError = (error) => error instanceof HandledCliError;
 const name = "webstudio";
-const version$1 = "0.290.0";
+const version$1 = "0.291.0";
 const description = "Webstudio CLI";
 const author = "Webstudio <github@webstudio.is>";
 const homepage = "https://webstudio.is";
@@ -280214,8 +280327,6 @@ Please check webstudio --help for more details`
   const pages2 = migratePages(siteData.build.pages);
   const publishablePages = getPublishablePages(pages2);
   const generatedPages = options.includeDraftPages ? getAllPages(pages2) : publishablePages;
-  const publishablePageIds = new Set(publishablePages.map((page2) => page2.id));
-  const assetSitemapPaths = /* @__PURE__ */ new Set();
   await writeWsAuthResources(
     generatedDir,
     pages2,
@@ -280556,11 +280667,6 @@ Please check webstudio --help for more details`
       index: siteData.assetIndex,
       requireCompleteEnumeration: options.template.includes("ssg")
     });
-    if (publishablePageIds.has(page2.id) && isPageEligibleForSitemap(page2)) {
-      for (const path2 of prerenderPaths) {
-        assetSitemapPaths.add(path2);
-      }
-    }
     for (const { file: file2, template } of getTemplates({
       pagePath: pagePath2,
       prerenderPaths
@@ -280607,21 +280713,10 @@ Please check webstudio --help for more details`
     await writeGeneratedFile(file2, content2);
   }
   const sitemap = getStaticSiteMapXml(pages2, siteData.build.updatedAt);
-  const sitemapPaths = new Set(sitemap.map(({ path: path2 }) => path2));
-  for (const path2 of [...assetSitemapPaths].sort()) {
-    if (sitemapPaths.has(path2)) {
-      continue;
-    }
-    sitemapPaths.add(path2);
-    sitemap.push({
-      path: path2,
-      lastModified: siteData.build.updatedAt.split("T")[0]
-    });
-  }
   await writeGeneratedFile(
     join$1(generatedDir, "$resources.sitemap.xml.ts"),
     `
-      export const sitemap = ${JSON.stringify(sitemap, null, 2)};
+      export const sitemap: Array<{ path: string; lastModified: string }> = ${JSON.stringify(sitemap, null, 2)};
     `
   );
   const assetsById = Object.fromEntries(
@@ -293321,8 +293416,7 @@ const uniqueCandidates = (candidates) => {
     return true;
   });
 };
-const resolveScreenshotBrowser = async (options, dependencies2 = defaultScreenshotDependencies) => {
-  const checked = [];
+const getScreenshotBrowserCandidates = async (options, dependencies2) => {
   const candidates = [];
   if (options.browserPath !== void 0) {
     candidates.push({
@@ -293330,6 +293424,7 @@ const resolveScreenshotBrowser = async (options, dependencies2 = defaultScreensh
       source: "option",
       browser: options.browser === "auto" ? inferBrowser(options.browserPath) : options.browser
     });
+    return candidates;
   }
   const envBrowserPath = dependencies2.env.WEBSTUDIO_BROWSER_PATH;
   if (envBrowserPath !== void 0 && envBrowserPath.length > 0) {
@@ -293371,7 +293466,17 @@ const resolveScreenshotBrowser = async (options, dependencies2 = defaultScreensh
       (left, right) => browserPreference[left.browser] - browserPreference[right.browser]
     )
   );
-  for (const candidate of uniqueCandidates(candidates)) {
+  return uniqueCandidates(candidates);
+};
+const resolveScreenshotBrowserCandidate = async (options, dependencies2, excludedPaths) => {
+  const checked = [];
+  for (const candidate of await getScreenshotBrowserCandidates(
+    options,
+    dependencies2
+  )) {
+    if (excludedPaths.has(candidate.path)) {
+      continue;
+    }
     checked.push(candidate.path);
     if (await isExecutable(candidate.path, dependencies2)) {
       return candidate;
@@ -293502,27 +293607,34 @@ const getScreenshotOutputPath = ({
   output ?? `${tmpdir()}/webstudio-screenshot-${now}${suffix}.${format2 === "jpeg" ? "jpg" : format2}`
 );
 let screenshotBatchSequence = 0;
-const getBrowserScreenshotOptions = (options, browserPath, output, dependencies2) => ({
-  browserPath,
-  output,
-  width: options.width,
-  height: options.height,
-  fullPage: options.fullPage,
-  includeImageMetrics: options.includeImageMetrics,
-  includeResourceMetrics: options.includeResourceMetrics,
-  includeContrastMetrics: options.includeContrastMetrics,
-  ...webstudioPageInstrumentation,
-  url: options.url,
-  httpCredentials: options.httpCredentials,
-  uid: dependencies2.getuid(),
-  waitUntil: options.waitUntil ?? defaultScreenshotWaitUntil,
-  waitForSelector: options.waitForSelector,
-  waitForTimeout: options.waitForTimeout ?? defaultScreenshotWaitForTimeout,
-  timeout: options.timeout ?? defaultScreenshotTimeout,
-  format: options.format,
-  quality: options.quality,
-  scale: options.scale
-});
+const getBrowserScreenshotOptions = (options, browserPath, output, dependencies2) => {
+  const timeout = options.timeout ?? defaultScreenshotTimeout;
+  return {
+    browserPath,
+    output,
+    width: options.width,
+    height: options.height,
+    fullPage: options.fullPage,
+    includeImageMetrics: options.includeImageMetrics,
+    includeResourceMetrics: options.includeResourceMetrics,
+    includeContrastMetrics: options.includeContrastMetrics,
+    ...webstudioPageInstrumentation,
+    url: options.url,
+    httpCredentials: options.httpCredentials,
+    uid: dependencies2.getuid(),
+    waitUntil: options.waitUntil ?? defaultScreenshotWaitUntil,
+    waitForSelector: options.waitForSelector,
+    waitForTimeout: options.waitForTimeout ?? defaultScreenshotWaitForTimeout,
+    timeout,
+    startupTimeout: Math.max(
+      1,
+      Math.min(defaultBrowserStartupTimeout, Math.floor(timeout / 2))
+    ),
+    format: options.format,
+    quality: options.quality,
+    scale: options.scale
+  };
+};
 const validateScreenshotArtifact = async (output, dependencies2) => {
   let bytesRead;
   try {
@@ -293574,36 +293686,80 @@ const captureResolvedScreenshot = async (options, browser, dependencies2, browse
     ...layout === void 0 ? {} : { layout }
   };
 };
-const captureScreenshot = async (options, dependencies2 = defaultScreenshotDependencies) => {
-  const browser = await resolveScreenshotBrowser(options, dependencies2);
-  return await captureResolvedScreenshot(options, browser, dependencies2);
+const captureScreenshot = async (options, dependencies2 = defaultScreenshotDependencies) => await withBrowserStartupFallback({
+  options,
+  dependencies: dependencies2,
+  state: createBrowserStartupState(),
+  attempt: async (browser) => await captureResolvedScreenshot(options, browser, dependencies2)
+});
+const createBrowserStartupError = (failures) => Object.assign(
+  new BrowserStartupError(
+    [
+      "Unable to start any discovered Chromium-family browser.",
+      ...failures.map(
+        ({ browser, error }) => `- ${browser.browser} (${browser.source}): ${browser.path}: ${error instanceof Error ? error.message : String(error)}`
+      )
+    ].join("\n")
+  ),
+  {
+    attempts: failures.map(({ browser }) => browser)
+  }
+);
+const createBrowserStartupState = () => ({
+  failedPaths: /* @__PURE__ */ new Set(),
+  failures: []
+});
+const withBrowserStartupFallback = async ({
+  options,
+  dependencies: dependencies2,
+  state,
+  attempt,
+  validateBrowser,
+  isCancelled = () => false
+}) => {
+  while (true) {
+    let browser;
+    try {
+      browser = await resolveScreenshotBrowserCandidate(
+        options,
+        dependencies2,
+        state.failedPaths
+      );
+    } catch (error) {
+      if (error instanceof BrowserNotFoundError && state.failures.length > 0) {
+        throw createBrowserStartupError(state.failures);
+      }
+      throw error;
+    }
+    validateBrowser?.(browser);
+    try {
+      return await attempt(browser);
+    } catch (error) {
+      if (error instanceof BrowserStartupError === false || isCancelled()) {
+        throw error;
+      }
+      if (state.failedPaths.has(browser.path) === false) {
+        state.failures.push({ browser, error });
+        state.failedPaths.add(browser.path);
+      }
+      if (options.browserPath !== void 0) {
+        throw createBrowserStartupError(state.failures);
+      }
+    }
+  }
 };
 const createScreenshotCaptureSession = (dependencies2 = defaultScreenshotDependencies) => {
-  let browserPromise;
   let browserSession;
+  let browserSessionCandidate;
   let browserSessionPromise;
   let closePromise;
   let closed = false;
+  const startupState = createBrowserStartupState();
   const assertOpen = () => {
     if (closed) {
       throw new Error("Screenshot capture session is closed.");
     }
   };
-  const getBrowser = async (options) => {
-    assertOpen();
-    const pendingBrowser = browserPromise ?? resolveScreenshotBrowser(options, dependencies2);
-    browserPromise = pendingBrowser;
-    try {
-      const browser = await pendingBrowser;
-      assertOpen();
-      return browser;
-    } catch (error) {
-      if (browserPromise === pendingBrowser) {
-        browserPromise = void 0;
-      }
-      throw error;
-    }
-  };
   const getBrowserSession = async (options) => {
     assertOpen();
     if (browserSession !== void 0) {
@@ -293626,27 +293782,48 @@ const createScreenshotCaptureSession = (dependencies2 = defaultScreenshotDepende
       throw error;
     }
   };
-  return {
-    async capture(options) {
-      const resolvedBrowser = await getBrowser(options);
-      if (options.browserPath !== void 0 && options.browserPath !== resolvedBrowser.path || options.browser !== "auto" && options.browser !== resolvedBrowser.browser) {
+  const getReadyBrowser = async (options, compatibleOptions = [options]) => {
+    const validateBrowser = (browser) => {
+      if (compatibleOptions.some(
+        (candidateOptions) => candidateOptions.browserPath !== void 0 && candidateOptions.browserPath !== browser.path || candidateOptions.browser !== "auto" && candidateOptions.browser !== browser.browser
+      )) {
         throw new Error(
           "A reusable screenshot session cannot switch browser executables."
         );
       }
-      const activeBrowserSession = await getBrowserSession(
-        getBrowserScreenshotOptions(
-          options,
-          resolvedBrowser.path,
-          options.output ?? "",
-          dependencies2
-        )
-      );
+    };
+    if (browserSession !== void 0 && browserSessionCandidate !== void 0) {
+      validateBrowser(browserSessionCandidate);
+      return { browser: browserSessionCandidate, session: browserSession };
+    }
+    return await withBrowserStartupFallback({
+      options,
+      dependencies: dependencies2,
+      state: startupState,
+      validateBrowser,
+      async attempt(browser) {
+        const session = await getBrowserSession(
+          getBrowserScreenshotOptions(
+            options,
+            browser.path,
+            options.output ?? "",
+            dependencies2
+          )
+        );
+        browserSessionCandidate = browser;
+        return { browser, session };
+      },
+      isCancelled: () => closed
+    });
+  };
+  return {
+    async capture(options) {
+      const { browser, session } = await getReadyBrowser(options);
       return await captureResolvedScreenshot(
         options,
-        resolvedBrowser,
+        browser,
         dependencies2,
-        activeBrowserSession
+        session
       );
     },
     async capturePage(optionsList) {
@@ -293655,14 +293832,10 @@ const createScreenshotCaptureSession = (dependencies2 = defaultScreenshotDepende
       if (firstOptions === void 0) {
         return [];
       }
-      const resolvedBrowser = await getBrowser(firstOptions);
-      if (optionsList.some(
-        (options) => options.browserPath !== void 0 && options.browserPath !== resolvedBrowser.path || options.browser !== "auto" && options.browser !== resolvedBrowser.browser
-      )) {
-        throw new Error(
-          "A reusable screenshot session cannot switch browser executables."
-        );
-      }
+      const { browser, session } = await getReadyBrowser(
+        firstOptions,
+        optionsList
+      );
       const startedAt = dependencies2.now();
       const batchSequence = screenshotBatchSequence;
       screenshotBatchSequence += 1;
@@ -293680,17 +293853,14 @@ const createScreenshotCaptureSession = (dependencies2 = defaultScreenshotDepende
             output,
             browserOptions: getBrowserScreenshotOptions(
               options,
-              resolvedBrowser.path,
+              browser.path,
               output,
               dependencies2
             )
           };
         })
       );
-      const activeBrowserSession = await getBrowserSession(
-        captures[0].browserOptions
-      );
-      const layouts = await activeBrowserSession.capturePage(
+      const layouts = await session.capturePage(
         captures.map((capture) => capture.browserOptions)
       );
       await Promise.all(
@@ -293706,7 +293876,7 @@ const createScreenshotCaptureSession = (dependencies2 = defaultScreenshotDepende
         const layout = toWebstudioLayout(capturedLayout);
         return {
           output,
-          browser: resolvedBrowser,
+          browser,
           viewport: { width: options.width, height: options.height },
           fullPage: options.fullPage === true,
           elapsedMs: layout.timings?.wallMs ?? 0,