webstudio 0.299.0 → 0.300.0

package/lib/cli.js

@@ -8054,7 +8054,10 @@ const videoAsset = object({
 });
 const fileAsset = object({
   ...baseAsset,
-  format: string$5(),
+  format: string$5().refine(
+    (format2) => FONT_FORMATS.has(format2) === false,
+    "Font formats must use font asset type"
+  ),
   meta: object({}),
   type: literal$2(assetType.enum.file)
 });
@@ -16058,6 +16061,92 @@ const mapBounded = async (values, concurrency, run) => {
   }
   return results;
 };
+const getAbortReason = (signal) => signal.reason ?? new DOMException("The operation was aborted", "AbortError");
+const throwIfSignalAborted = (signal) => {
+  if (signal?.aborted) {
+    throw getAbortReason(signal);
+  }
+};
+const awaitWithSignal = async (task, signal) => {
+  if (signal === void 0) {
+    return await task;
+  }
+  return await new Promise((resolve2, reject) => {
+    const cleanup = () => signal.removeEventListener("abort", onAbort);
+    const onAbort = () => {
+      cleanup();
+      reject(getAbortReason(signal));
+    };
+    signal.addEventListener("abort", onAbort, { once: true });
+    Promise.resolve(task).then(
+      (value2) => {
+        cleanup();
+        resolve2(value2);
+      },
+      (error) => {
+        cleanup();
+        reject(error);
+      }
+    );
+    if (signal.aborted) {
+      onAbort();
+    }
+  });
+};
+const createConcurrencyLimiter = ({
+  concurrency,
+  signal
+}) => {
+  if (Number.isSafeInteger(concurrency) === false || concurrency <= 0) {
+    throw new TypeError("Concurrency must be a positive safe integer");
+  }
+  let active = 0;
+  const waiters = [];
+  const acquire = async () => {
+    throwIfSignalAborted(signal);
+    if (active < concurrency) {
+      active += 1;
+      return;
+    }
+    await new Promise((resolve2, reject) => {
+      let waiter;
+      const onAbort = () => {
+        const index2 = waiters.indexOf(waiter);
+        if (index2 !== -1) {
+          waiters.splice(index2, 1);
+        }
+        if (signal !== void 0) {
+          reject(getAbortReason(signal));
+        }
+      };
+      waiter = {
+        start: () => {
+          signal?.removeEventListener("abort", onAbort);
+          resolve2();
+        }
+      };
+      waiters.push(waiter);
+      signal?.addEventListener("abort", onAbort, { once: true });
+    });
+  };
+  const release2 = () => {
+    const next = waiters.shift();
+    if (next === void 0) {
+      active -= 1;
+      return;
+    }
+    next.start();
+  };
+  return async (run) => {
+    await acquire();
+    try {
+      throwIfSignalAborted(signal);
+      return await run();
+    } finally {
+      release2();
+    }
+  };
+};
 const isJsonObject$1 = (value2) => typeof value2 === "object" && value2 !== null && Array.isArray(value2) === false;
 const getJsonReferenceMarkerValue = (value2) => {
   if (isJsonObject$1(value2) === false) {
@@ -17916,7 +18005,7 @@ const includesField = (query, predicate) => {
   return included;
 };
 const requiresRuntimeDocumentData = (plan) => plan.queries.some(
-  (query) => includesField(
+  (query) => query.content.mode !== "none" || includesField(
     query,
     (field) => field.length === 1 && isAssetQueryRuntimeField(field[0])
   )
@@ -25301,7 +25390,7 @@ class DocumentSourceCompilationAggregateError extends Error {
     this.errors = Object.freeze([...errors]);
   }
 }
-const assertActive$1 = (signal) => {
+const assertActive$2 = (signal) => {
   if (signal?.aborted) {
     throw new DocumentSourceCompilationError({
       code: "REQUEST_CANCELLED",
@@ -25320,7 +25409,7 @@ const compileDocumentSourceGraph = async ({
   onDocumentProperties,
   signal
 }) => {
-  assertActive$1(signal);
+  assertActive$2(signal);
   const getDocumentPath = (documentId) => {
     const document2 = documentId === void 0 ? void 0 : documents.find(({ id: id2 }) => id2 === documentId);
     if (document2 === void 0) {
@@ -25399,7 +25488,7 @@ const compileDocumentSourceGraph = async ({
               documentId
             });
           }
-          assertActive$1(signal);
+          assertActive$2(signal);
           const result2 = await analyzeDocumentSource({
             format: document2.format,
             source: document2.source,
@@ -25412,7 +25501,7 @@ const compileDocumentSourceGraph = async ({
             value: { document: document2, analyzedDocument: result2 }
           };
         } catch (cause) {
-          assertActive$1(signal);
+          assertActive$2(signal);
           if (cause instanceof DocumentSourceCompilationError) {
             return { status: "rejected", reason: cause, documentId };
           }
@@ -25488,7 +25577,7 @@ const compileDocumentSourceGraph = async ({
       }
     }
   }
-  assertActive$1(signal);
+  assertActive$2(signal);
   if (compilationErrors.length === 1) {
     throw compilationErrors[0];
   }
@@ -26939,6 +27028,176 @@ const getDocumentSourceCacheKey = ({
   revision,
   format: format2
 }) => serializeJsonDeterministically([contentRef, revision, format2 ?? null]);
+class ResourceResolutionError extends Error {
+  code;
+  resourceIds;
+  constructor({
+    code: code2,
+    message,
+    resourceIds = [],
+    cause
+  }) {
+    super(message, { cause });
+    this.name = "ResourceResolutionError";
+    this.code = code2;
+    this.resourceIds = Object.freeze([...resourceIds]);
+  }
+}
+const assertActive$1 = (signal) => {
+  if (signal?.aborted) {
+    throw new ResourceResolutionError({
+      code: "REQUEST_CANCELLED",
+      message: "Resource resolution was cancelled",
+      cause: signal.reason
+    });
+  }
+};
+const getReachableResources = ({
+  resourcesById,
+  rootIds
+}) => {
+  const state = /* @__PURE__ */ new Map();
+  const stack = [];
+  const ordered = [];
+  const visit2 = (resourceId2, sourceId) => {
+    const resource2 = resourcesById.get(resourceId2);
+    if (resource2 === void 0) {
+      throw new ResourceResolutionError({
+        code: sourceId === void 0 ? "ROOT_NOT_FOUND" : "DEPENDENCY_NOT_FOUND",
+        message: sourceId === void 0 ? `Resource graph root ${resourceId2} does not exist` : `Resource ${sourceId} dependency ${resourceId2} does not exist`,
+        resourceIds: sourceId === void 0 ? [resourceId2] : [sourceId, resourceId2]
+      });
+    }
+    const resourceState = state.get(resourceId2);
+    if (resourceState === "visited") {
+      return;
+    }
+    if (resourceState === "visiting") {
+      const cycleStart = stack.indexOf(resourceId2);
+      const cycle = [...stack.slice(cycleStart), resourceId2];
+      throw new ResourceResolutionError({
+        code: "CYCLE",
+        message: `Resource graph contains a cycle: ${cycle.join(" -> ")}`,
+        resourceIds: cycle
+      });
+    }
+    state.set(resourceId2, "visiting");
+    stack.push(resourceId2);
+    for (const dependencyId of resource2.dependencies) {
+      visit2(dependencyId, resource2.id);
+    }
+    stack.pop();
+    state.set(resourceId2, "visited");
+    ordered.push(resource2);
+  };
+  for (const rootId of new Set(rootIds)) {
+    visit2(rootId);
+  }
+  return ordered;
+};
+const resolveResources = async ({
+  resources,
+  rootIds,
+  concurrency,
+  signal
+}) => {
+  if (Number.isSafeInteger(concurrency) === false || concurrency <= 0) {
+    throw new TypeError("Resource resolution concurrency must be positive");
+  }
+  assertActive$1(signal);
+  const resourcesById = /* @__PURE__ */ new Map();
+  for (const resource2 of resources) {
+    if (resourcesById.has(resource2.id)) {
+      throw new ResourceResolutionError({
+        code: "DUPLICATE_RESOURCE",
+        message: `Resource graph contains duplicate resource ${resource2.id}`,
+        resourceIds: [resource2.id]
+      });
+    }
+    resourcesById.set(resource2.id, resource2);
+  }
+  const reachableResources = getReachableResources({
+    resourcesById,
+    rootIds
+  });
+  const limit2 = createConcurrencyLimiter({ concurrency, signal });
+  const documents = /* @__PURE__ */ new Map();
+  const pending = /* @__PURE__ */ new Map();
+  const resolveResource = (resourceId2) => {
+    const previous2 = pending.get(resourceId2);
+    if (previous2 !== void 0) {
+      return previous2;
+    }
+    const resource2 = resourcesById.get(resourceId2);
+    const resolution2 = (async () => {
+      const dependencyDocuments = /* @__PURE__ */ new Map();
+      let dependencyValues;
+      try {
+        dependencyValues = await Promise.all(
+          resource2.dependencies.map(resolveResource)
+        );
+      } catch (cause) {
+        if (cause instanceof ResourceResolutionError && cause.code === "RESOLUTION_FAILED") {
+          throw new ResourceResolutionError({
+            code: cause.code,
+            message: `Resource dependency path ${[
+              resource2.id,
+              ...cause.resourceIds
+            ].join(" -> ")} could not be resolved`,
+            resourceIds: [resource2.id, ...cause.resourceIds],
+            cause: cause.cause
+          });
+        }
+        throw cause;
+      }
+      for (const [index2, dependencyId] of resource2.dependencies.entries()) {
+        dependencyDocuments.set(
+          dependencyId,
+          dependencyValues[index2]
+        );
+      }
+      assertActive$1(signal);
+      try {
+        return await limit2(async () => {
+          assertActive$1(signal);
+          const document2 = await awaitWithSignal(
+            resource2.resolve({
+              documents: dependencyDocuments,
+              signal
+            }),
+            signal
+          );
+          assertActive$1(signal);
+          return document2;
+        });
+      } catch (cause) {
+        if (signal?.aborted) {
+          assertActive$1(signal);
+        }
+        if (cause instanceof ResourceResolutionError) {
+          throw cause;
+        }
+        throw new ResourceResolutionError({
+          code: "RESOLUTION_FAILED",
+          message: `Resource ${resource2.id} could not be resolved`,
+          resourceIds: [resource2.id],
+          cause
+        });
+      }
+    })();
+    pending.set(resourceId2, resolution2);
+    return resolution2;
+  };
+  const roots = await Promise.all(rootIds.map(resolveResource));
+  for (const resource2 of reachableResources) {
+    const document2 = await pending.get(resource2.id);
+    documents.set(resource2.id, document2);
+  }
+  return Object.freeze({
+    roots: Object.freeze(roots),
+    documents
+  });
+};
 class DocumentGraphResolutionError extends Error {
   code;
   documentId;
@@ -26992,7 +27251,7 @@ const resolveDocumentGraph = async ({
     assertActive(signal);
     const node2 = group.representative;
     try {
-      const source = await load2(node2, { signal });
+      const source = await awaitWithSignal(load2(node2, { signal }), signal);
       for (const groupedNode of group.nodes) {
         sources.set(groupedNode.id, source);
       }
@@ -27009,75 +27268,105 @@ const resolveDocumentGraph = async ({
     }
   });
   const edgesBySourceId = getDocumentGraphEdgesBySourceId(graph.edges);
-  const values = /* @__PURE__ */ new Map();
-  for (const node2 of closure) {
-    assertActive(signal);
-    const references = /* @__PURE__ */ new Map();
-    for (const edge of edgesBySourceId.get(node2.id) ?? []) {
-      const targetNode = nodesById.get(edge.reference.documentId);
-      if (targetNode === void 0 || values.has(edge.reference.documentId) === false) {
-        throw new DocumentGraphResolutionError({
-          code: "DOCUMENT_ASSEMBLY_FAILED",
-          message: `Document ${node2.id} dependency ${edge.reference.documentId} is unavailable`,
-          documentId: node2.id,
-          referenceId: edge.referenceId
-        });
-      }
-      const targetValue = values.get(edge.reference.documentId);
-      let selected;
-      if (select2 === void 0) {
-        if (edge.reference.representation.type !== "document") {
+  const resources = closure.map((node2) => ({
+    id: node2.id,
+    dependencies: (edgesBySourceId.get(node2.id) ?? []).map(
+      (edge) => edge.reference.documentId
+    ),
+    resolve: async ({ documents }) => {
+      assertActive(signal);
+      const references = /* @__PURE__ */ new Map();
+      for (const edge of edgesBySourceId.get(node2.id) ?? []) {
+        const targetNode = nodesById.get(edge.reference.documentId);
+        if (targetNode === void 0 || documents.has(edge.reference.documentId) === false) {
           throw new DocumentGraphResolutionError({
-            code: "REPRESENTATION_SELECTOR_REQUIRED",
-            message: `Document ${node2.id} reference ${edge.referenceId} requires a representation selector`,
+            code: "DOCUMENT_ASSEMBLY_FAILED",
+            message: `Document ${node2.id} dependency ${edge.reference.documentId} is unavailable`,
             documentId: node2.id,
             referenceId: edge.referenceId
           });
         }
-        selected = targetValue;
-      } else {
-        try {
-          selected = await select2({
-            reference: edge.reference,
-            value: targetValue,
-            sourceNode: node2,
-            targetNode
-          });
-        } catch (error) {
-          throw new DocumentGraphResolutionError({
-            code: "DOCUMENT_SELECTION_FAILED",
-            message: `Document ${node2.id} reference ${edge.referenceId} could not be selected`,
-            documentId: node2.id,
-            referenceId: edge.referenceId,
-            cause: error
-          });
+        const targetValue = documents.get(edge.reference.documentId);
+        let selected;
+        if (select2 === void 0) {
+          if (edge.reference.representation.type !== "document") {
+            throw new DocumentGraphResolutionError({
+              code: "REPRESENTATION_SELECTOR_REQUIRED",
+              message: `Document ${node2.id} reference ${edge.referenceId} requires a representation selector`,
+              documentId: node2.id,
+              referenceId: edge.referenceId
+            });
+          }
+          selected = targetValue;
+        } else {
+          try {
+            selected = await select2({
+              reference: edge.reference,
+              value: targetValue,
+              sourceNode: node2,
+              targetNode
+            });
+          } catch (error) {
+            throw new DocumentGraphResolutionError({
+              code: "DOCUMENT_SELECTION_FAILED",
+              message: `Document ${node2.id} reference ${edge.referenceId} could not be selected`,
+              documentId: node2.id,
+              referenceId: edge.referenceId,
+              cause: error
+            });
+          }
+        }
+        references.set(edge.referenceId, selected);
+      }
+      if (sources.has(node2.id) === false) {
+        throw new DocumentGraphResolutionError({
+          code: "DOCUMENT_ASSEMBLY_FAILED",
+          message: `Document ${node2.id} source is unavailable`,
+          documentId: node2.id
+        });
+      }
+      const source = sources.get(node2.id);
+      try {
+        return await assemble({ node: node2, source, references });
+      } catch (error) {
+        if (error instanceof DocumentGraphResolutionError) {
+          throw error;
         }
+        throw new DocumentGraphResolutionError({
+          code: "DOCUMENT_ASSEMBLY_FAILED",
+          message: `Document ${node2.id} could not be assembled`,
+          documentId: node2.id,
+          cause: error
+        });
       }
-      references.set(edge.referenceId, selected);
     }
-    if (sources.has(node2.id) === false) {
-      throw new DocumentGraphResolutionError({
-        code: "DOCUMENT_ASSEMBLY_FAILED",
-        message: `Document ${node2.id} source is unavailable`,
-        documentId: node2.id
-      });
+  }));
+  try {
+    const resolved = await resolveResources({
+      resources,
+      rootIds,
+      // Preserve deterministic dependency-first document assembly. Source
+      // loading above remains bounded and concurrent.
+      concurrency: 1,
+      signal
+    });
+    return Object.freeze({
+      roots: resolved.roots,
+      values: resolved.documents
+    });
+  } catch (error) {
+    if (error instanceof ResourceResolutionError && error.cause instanceof DocumentGraphResolutionError) {
+      throw error.cause;
     }
-    const source = sources.get(node2.id);
-    try {
-      values.set(node2.id, await assemble({ node: node2, source, references }));
-    } catch (error) {
+    if (error instanceof ResourceResolutionError && error.code === "REQUEST_CANCELLED") {
       throw new DocumentGraphResolutionError({
-        code: "DOCUMENT_ASSEMBLY_FAILED",
-        message: `Document ${node2.id} could not be assembled`,
-        documentId: node2.id,
-        cause: error
+        code: "REQUEST_CANCELLED",
+        message: "Document graph resolution was cancelled",
+        cause: error.cause
       });
     }
+    throw error;
   }
-  return Object.freeze({
-    roots: Object.freeze(rootIds.map((rootId) => values.get(rootId))),
-    values
-  });
 };
 class DocumentResolutionLimitError extends Error {
   code;
@@ -27109,55 +27398,6 @@ class DocumentResolutionLimitError extends Error {
     this.totalByteLimit = totalByteLimit;
   }
 }
-const createConcurrencyLimiter = (concurrency, signal) => {
-  let active = 0;
-  const waiters = [];
-  const acquire = async () => {
-    signal?.throwIfAborted();
-    if (active < concurrency) {
-      active += 1;
-      return;
-    }
-    await new Promise((resolve2, reject) => {
-      let waiter;
-      const onAbort = () => {
-        const index2 = waiters.indexOf(waiter);
-        if (index2 !== -1) {
-          waiters.splice(index2, 1);
-        }
-        try {
-          signal?.throwIfAborted();
-        } catch (error) {
-          reject(error);
-        }
-      };
-      waiter = {
-        start: () => {
-          signal?.removeEventListener("abort", onAbort);
-          resolve2();
-        }
-      };
-      waiters.push(waiter);
-      signal?.addEventListener("abort", onAbort, { once: true });
-    });
-  };
-  const release2 = () => {
-    const next = waiters.shift();
-    if (next === void 0) {
-      active -= 1;
-      return;
-    }
-    next.start();
-  };
-  return async (run) => {
-    await acquire();
-    try {
-      return await run();
-    } finally {
-      release2();
-    }
-  };
-};
 const resolveWithSessionDocumentLoader = async ({
   graph,
   rootIds,
@@ -27286,7 +27526,7 @@ const createDocumentResolutionSession = ({
     sizeCalculation: ({ byteLength }) => Math.max(1, byteLength)
   });
   const pending = /* @__PURE__ */ new Map();
-  const limit2 = createConcurrencyLimiter(concurrency, signal);
+  const limit2 = createConcurrencyLimiter({ concurrency, signal });
   const assertSessionSignal = (requestedSignal) => {
     if (requestedSignal !== void 0 && requestedSignal !== signal) {
       throw new TypeError("Document resolution session signal does not match");
@@ -27295,34 +27535,7 @@ const createDocumentResolutionSession = ({
   };
   const waitForSessionTask = async (task) => {
     assertSessionSignal();
-    if (signal === void 0) {
-      return await task;
-    }
-    return await new Promise((resolve2, reject) => {
-      const cleanup = () => signal.removeEventListener("abort", onAbort);
-      const onAbort = () => {
-        cleanup();
-        try {
-          signal.throwIfAborted();
-        } catch (error) {
-          reject(error);
-        }
-      };
-      signal.addEventListener("abort", onAbort, { once: true });
-      task.then(
-        (value2) => {
-          cleanup();
-          resolve2(value2);
-        },
-        (error) => {
-          cleanup();
-          reject(error);
-        }
-      );
-      if (signal.aborted) {
-        onAbort();
-      }
-    });
+    return await awaitWithSignal(task, signal);
   };
   const loadSessionDocument = async (node2, options) => {
     assertSessionSignal(options.signal);
@@ -27561,7 +27774,7 @@ const getInlineDocumentIds = (artifact) => {
     )
   );
 };
-const createContentRuntimeArtifact = (artifact) => {
+const createContentRuntimeArtifact = (artifact, { includeContents = true } = {}) => {
   const inlineDocumentIds = getInlineDocumentIds(artifact);
   const documentGraph = artifact.documentGraph === void 0 ? void 0 : {
     nodes: artifact.documentGraph.nodes.filter(
@@ -27580,7 +27793,7 @@ const createContentRuntimeArtifact = (artifact) => {
     revision: artifact.integrity.checksum,
     documents: artifact.documents,
     ...documentGraph === void 0 ? {} : { documentGraph },
-    ...artifact.contents === void 0 ? {} : { contents: artifact.contents },
+    ...includeContents && artifact.contents !== void 0 ? { contents: artifact.contents } : {},
     ...artifact.assetReferences === void 0 ? {} : { assetReferences: artifact.assetReferences },
     ...artifact.assetValueReferences === void 0 ? {} : { assetValueReferences: artifact.assetValueReferences },
     ...artifact.queries === void 0 ? {} : { queries: artifact.queries }
@@ -59147,6 +59360,7 @@ const templates = _enum([
   "ssg-netlify",
   "ssg-vercel"
 ]);
+const publishedDeploymentDestination = "saas";
 const deployment = union([
   object({
     destination: literal$2("static"),
@@ -59156,7 +59370,7 @@ const deployment = union([
     templates: array(templates)
   }),
   object({
-    destination: literal$2("saas").optional(),
+    destination: literal$2(publishedDeploymentDestination).optional(),
     target: _enum(["staging", "production"]).optional(),
     domains: array(string$5()),
     assetsDomain: string$5().optional(),
@@ -59167,6 +59381,7 @@ const deployment = union([
     excludeWstdDomainFromSearch: boolean$2().optional()
   })
 ]);
+const isPublishedDeployment = (deployment2) => deployment2?.destination === publishedDeploymentDestination;
 const webstudioFragment = object({
   children: array(instanceChild),
   instances: array(instance$1),
@@ -61837,85 +62052,298 @@ const createScope = (occupiedIdentifiers = [], normalizeName2 = normalizeJsName,
     getName
   };
 };
+const getExpressionDataSourceIds = (expressions) => {
+  const dataSourceIds = /* @__PURE__ */ new Set();
+  for (const expression2 of expressions) {
+    if (expression2 === void 0) {
+      continue;
+    }
+    for (const identifier2 of getExpressionIdentifiers(expression2)) {
+      const dataSourceId2 = decodeDataVariableId(identifier2);
+      if (dataSourceId2 !== void 0) {
+        dataSourceIds.add(dataSourceId2);
+      }
+    }
+  }
+  return dataSourceIds;
+};
+const getResourceDataSourceIds = (resource2) => {
+  return getExpressionDataSourceIds([
+    resource2.url,
+    ...(resource2.searchParams ?? []).map(({ value: value2 }) => value2),
+    ...resource2.headers.map(({ value: value2 }) => value2),
+    resource2.body
+  ]);
+};
+const getResourceDependencyIds = ({
+  resource: resource2,
+  dataSources
+}) => {
+  const dependencyIds = /* @__PURE__ */ new Set();
+  for (const dataSourceId2 of getResourceDataSourceIds(resource2)) {
+    const dataSource2 = dataSources.get(dataSourceId2);
+    if (dataSource2?.type === "resource") {
+      dependencyIds.add(dataSource2.resourceId);
+    }
+  }
+  return dependencyIds;
+};
+const getPageResourceRootIds = ({
+  page: page2,
+  instances,
+  props: props2,
+  dataSources
+}) => {
+  const instanceIds = findTreeInstanceIds(instances, page2.rootInstanceId);
+  const expressions = [
+    page2.title,
+    page2.meta?.description,
+    page2.meta?.excludePageFromSearch,
+    page2.meta?.language,
+    page2.meta?.socialImageUrl,
+    page2.meta?.status,
+    page2.meta?.redirect,
+    page2.meta?.content,
+    ...(page2.meta?.custom ?? []).filter(({ property: property2 }) => property2.trim().length > 0).map(({ content: content2 }) => content2)
+  ];
+  for (const prop2 of props2.values()) {
+    if (instances.size > 0 && instanceIds.has(prop2.instanceId) === false) {
+      continue;
+    }
+    if (prop2.type === "expression") {
+      expressions.push(prop2.value);
+    }
+    if (prop2.type === "action") {
+      for (const action2 of prop2.value) {
+        expressions.push(action2.code);
+      }
+    }
+  }
+  for (const instanceId2 of instanceIds) {
+    const instance2 = instances.get(instanceId2);
+    if (instance2 === void 0) {
+      continue;
+    }
+    for (const child of instance2.children) {
+      if (child.type === "expression") {
+        expressions.push(child.value);
+      }
+    }
+  }
+  const resourceIds = /* @__PURE__ */ new Set();
+  for (const dataSourceId2 of getExpressionDataSourceIds(expressions)) {
+    const dataSource2 = dataSources.get(dataSourceId2);
+    if (dataSource2?.type === "resource") {
+      resourceIds.add(dataSource2.resourceId);
+    }
+  }
+  return resourceIds;
+};
+const generateResourceRequestFields = ({
+  resource: resource2,
+  indent: indent2,
+  dataSources,
+  usedDataSources,
+  scope: scope2
+}) => {
+  let generated2 = "";
+  generated2 += `${indent2}name: ${JSON.stringify(resource2.name)},
+`;
+  if (resource2.control !== void 0) {
+    generated2 += `${indent2}control: "${resource2.control}",
+`;
+  }
+  const url2 = generateExpression({
+    expression: resource2.url,
+    dataSources,
+    usedDataSources,
+    scope: scope2
+  });
+  generated2 += `${indent2}url: ${url2},
+`;
+  generated2 += `${indent2}searchParams: [
+`;
+  for (const searchParam of resource2.searchParams ?? []) {
+    const value2 = generateExpression({
+      expression: searchParam.value,
+      dataSources,
+      usedDataSources,
+      scope: scope2
+    });
+    generated2 += `${indent2}  { name: "${searchParam.name}", value: ${value2} },
+`;
+  }
+  generated2 += `${indent2}],
+`;
+  generated2 += `${indent2}method: "${resource2.method}",
+`;
+  generated2 += `${indent2}headers: [
+`;
+  for (const header2 of resource2.headers) {
+    const value2 = generateExpression({
+      expression: header2.value,
+      dataSources,
+      usedDataSources,
+      scope: scope2
+    });
+    generated2 += `${indent2}  { name: "${header2.name}", value: ${value2} },
+`;
+  }
+  generated2 += `${indent2}],
+`;
+  if (resource2.body !== void 0 && resource2.body.length > 0) {
+    const body2 = generateExpression({
+      expression: resource2.body,
+      dataSources,
+      usedDataSources,
+      scope: scope2
+    });
+    generated2 += `${indent2}body: ${body2},
+`;
+  }
+  return generated2;
+};
 const generateResources = ({
   scope: scope2,
   page: page2,
   dataSources,
   props: props2,
   resources,
+  instances = /* @__PURE__ */ new Map(),
   contentBlockResourceSelections = []
 }) => {
   const usedDataSources = /* @__PURE__ */ new Map();
-  const contentSelectionDataSourceIds = /* @__PURE__ */ new Set();
-  const generatedResourceIds = new Set(resources.keys());
+  const contentInputDataSourceIds = /* @__PURE__ */ new Set();
   const selectedResourceIds = new Set(
     contentBlockResourceSelections.flatMap(
       ({ candidates }) => candidates.flatMap(({ resourceIds }) => resourceIds)
     )
   );
+  const pageInstanceIds = findTreeInstanceIds(instances, page2.rootInstanceId);
+  const actionResourceProps = Array.from(props2.values()).filter(
+    (prop2) => (instances.size === 0 || pageInstanceIds.has(prop2.instanceId)) && prop2.type === "resource" && resources.has(prop2.value)
+  );
+  const actionResourceIds = new Set(
+    actionResourceProps.map((prop2) => prop2.value)
+  );
+  const resourceDataSourceByResourceId = new Map(
+    Array.from(dataSources.values()).filter(
+      (dataSource2) => dataSource2.type === "resource" && resources.has(dataSource2.resourceId)
+    ).map((dataSource2) => [dataSource2.resourceId, dataSource2])
+  );
+  const rootResourceIds = getPageResourceRootIds({
+    page: page2,
+    instances,
+    props: props2,
+    dataSources
+  });
+  for (const { sourceExpression } of contentBlockResourceSelections) {
+    for (const dataSourceId2 of getExpressionDataSourceIds([sourceExpression])) {
+      const dataSource2 = dataSources.get(dataSourceId2);
+      if (dataSource2?.type === "resource") {
+        rootResourceIds.add(dataSource2.resourceId);
+        contentInputDataSourceIds.add(dataSource2.id);
+      }
+    }
+  }
+  for (const resourceId2 of selectedResourceIds) {
+    const resource2 = resources.get(resourceId2);
+    if (resource2 === void 0) {
+      continue;
+    }
+    for (const dataSourceId2 of getResourceDataSourceIds(resource2)) {
+      const dataSource2 = dataSources.get(dataSourceId2);
+      if (dataSource2?.type !== "resource") {
+        continue;
+      }
+      if (selectedResourceIds.has(dataSource2.resourceId)) {
+        throw new Error(
+          "Dynamic Content Block Resources cannot depend on another selected Resource"
+        );
+      }
+      rootResourceIds.add(dataSource2.resourceId);
+      contentInputDataSourceIds.add(dataSource2.id);
+    }
+  }
+  const graphResourceIds = /* @__PURE__ */ new Set();
+  const resourceDependencies = /* @__PURE__ */ new Map();
+  const addResourceAndDependencies = (resourceId2) => {
+    if (graphResourceIds.has(resourceId2)) {
+      return;
+    }
+    const resource2 = resources.get(resourceId2);
+    if (resource2 === void 0) {
+      return;
+    }
+    graphResourceIds.add(resourceId2);
+    const dependencies2 = Array.from(
+      getResourceDependencyIds({
+        resource: resource2,
+        dataSources
+      })
+    );
+    resourceDependencies.set(resourceId2, dependencies2);
+    for (const dependencyId of dependencies2) {
+      addResourceAndDependencies(dependencyId);
+    }
+  };
+  for (const dataSource2 of resourceDataSourceByResourceId.values()) {
+    if (selectedResourceIds.has(dataSource2.resourceId) === false && actionResourceIds.has(dataSource2.resourceId) === false) {
+      addResourceAndDependencies(dataSource2.resourceId);
+    }
+  }
+  for (const resourceId2 of rootResourceIds) {
+    addResourceAndDependencies(resourceId2);
+  }
+  for (const resourceId2 of actionResourceIds) {
+    addResourceAndDependencies(resourceId2);
+  }
   let generatedRequests = "";
   for (const resource2 of resources.values()) {
-    let generatedRequest = "";
     const resourceName = scope2.getName(resource2.id, resource2.name);
-    generatedRequest += `  const ${resourceName}: ResourceRequest = {
-`;
-    generatedRequest += `    name: ${JSON.stringify(resource2.name)},
-`;
-    if (resource2.control !== void 0) {
-      generatedRequest += `    control: "${resource2.control}",
-`;
-    }
-    const url2 = generateExpression({
-      expression: resource2.url,
-      dataSources,
-      usedDataSources,
-      scope: scope2
-    });
-    generatedRequest += `    url: ${url2},
-`;
-    generatedRequest += `    searchParams: [
-`;
-    for (const searchParam of resource2.searchParams ?? []) {
-      const value2 = generateExpression({
-        expression: searchParam.value,
+    if (graphResourceIds.has(resource2.id)) {
+      const requestDataSources = /* @__PURE__ */ new Map();
+      const fields = generateResourceRequestFields({
+        resource: resource2,
+        indent: "      ",
         dataSources,
-        usedDataSources,
+        usedDataSources: requestDataSources,
         scope: scope2
       });
-      generatedRequest += `      { name: "${searchParam.name}", value: ${value2} },
+      let generatedRequest = `  const ${resourceName} = (documents: ReadonlyMap<string, unknown>): ResourceRequest => {
 `;
-    }
-    generatedRequest += `    ],
+      for (const dataSource2 of requestDataSources.values()) {
+        usedDataSources.set(dataSource2.id, dataSource2);
+        if (dataSource2.type !== "resource") {
+          continue;
+        }
+        const name2 = scope2.getName(dataSource2.id, dataSource2.name);
+        generatedRequest += `    const ${name2} = documents.get(${JSON.stringify(
+          dataSource2.resourceId
+        )})
 `;
-    generatedRequest += `    method: "${resource2.method}",
+      }
+      generatedRequest += `    return {
 `;
-    generatedRequest += `    headers: [
+      generatedRequest += fields;
+      generatedRequest += `    }
 `;
-    for (const header2 of resource2.headers) {
-      const value2 = generateExpression({
-        expression: header2.value,
-        dataSources,
-        usedDataSources,
-        scope: scope2
-      });
-      generatedRequest += `      { name: "${header2.name}", value: ${value2} },
+      generatedRequest += `  }
 `;
+      generatedRequests += generatedRequest;
+      continue;
     }
-    generatedRequest += `    ],
+    generatedRequests += `  const ${resourceName}: ResourceRequest = {
 `;
-    if (resource2.body !== void 0 && resource2.body.length > 0) {
-      const body2 = generateExpression({
-        expression: resource2.body,
-        dataSources,
-        usedDataSources,
-        scope: scope2
-      });
-      generatedRequest += `    body: ${body2},
-`;
-    }
-    generatedRequest += `  }
+    generatedRequests += generateResourceRequestFields({
+      resource: resource2,
+      indent: "    ",
+      dataSources,
+      usedDataSources,
+      scope: scope2
+    });
+    generatedRequests += `  }
 `;
-    generatedRequests += generatedRequest;
   }
   const generatedContentSelections = contentBlockResourceSelections.map(
     ({ sourceExpression, candidates }) => {
@@ -61936,7 +62364,7 @@ const generateResources = ({
         }
       }
       for (const dataSource2 of selectionDataSources.values()) {
-        contentSelectionDataSourceIds.add(dataSource2.id);
+        contentInputDataSourceIds.add(dataSource2.id);
         usedDataSources.set(dataSource2.id, dataSource2);
       }
       return { source, candidates };
@@ -61957,68 +62385,108 @@ const generateResources = ({
 `;
       }
     }
-    if (dataSource2.type === "resource" && contentSelectionDataSourceIds.has(dataSource2.id)) {
+    if (dataSource2.type === "resource" && contentInputDataSourceIds.has(dataSource2.id)) {
       const name2 = scope2.getName(dataSource2.id, dataSource2.name);
       const resourceName = scope2.getName(
         dataSource2.resourceId,
         dataSource2.name
       );
-      generatedVariables += `  const ${name2} = _props.resources?.[${JSON.stringify(resourceName)}]
+      generatedVariables += `  const ${name2} = _props.resources?.[${JSON.stringify(
+        resourceName
+      )}]
 `;
     }
   }
   let generated2 = "";
   generated2 += `import type { System, ResourceRequest } from "@webstudio-is/sdk";
+`;
+  generated2 += `import type { ResourceRequestGraph } from "@webstudio-is/sdk/runtime";
 `;
   generated2 += `export const getResources = (_props: { system: System; resources?: Record<string, any> }) => {
 `;
   generated2 += generatedVariables;
   generated2 += generatedRequests;
-  const actionResourceIds = /* @__PURE__ */ new Set();
-  for (const prop2 of props2.values()) {
-    if (prop2.type === "resource" && generatedResourceIds.has(prop2.value)) {
-      actionResourceIds.add(prop2.value);
+  generated2 += `  const _data: ResourceRequestGraph = {
+`;
+  generated2 += `    resources: [
+`;
+  for (const resourceId2 of graphResourceIds) {
+    const resource2 = resources.get(resourceId2);
+    if (resource2 === void 0) {
+      continue;
     }
+    const name2 = scope2.getName(resourceId2, resource2.name);
+    const dependencies2 = resourceDependencies.get(resourceId2) ?? [];
+    generated2 += `      { id: ${JSON.stringify(
+      resourceId2
+    )}, outputName: ${JSON.stringify(name2)}, dependencies: ${JSON.stringify(
+      dependencies2
+    )}, createRequest: ${name2} },
+`;
   }
-  generated2 += `  const _data = new Map<string, ResourceRequest>([
+  generated2 += `    ],
 `;
-  for (const dataSource2 of dataSources.values()) {
-    if (dataSource2.type === "resource" && generatedResourceIds.has(dataSource2.resourceId) && selectedResourceIds.has(dataSource2.resourceId) === false && actionResourceIds.has(dataSource2.resourceId) === false) {
-      const name2 = scope2.getName(dataSource2.resourceId, dataSource2.name);
-      generated2 += `    ["${name2}", ${name2}],
+  generated2 += `    rootIds: [
+`;
+  for (const resourceId2 of rootResourceIds) {
+    if (graphResourceIds.has(resourceId2) && selectedResourceIds.has(resourceId2) === false && actionResourceIds.has(resourceId2) === false) {
+      generated2 += `      ${JSON.stringify(resourceId2)},
 `;
     }
   }
-  generated2 += `  ])
+  generated2 += `    ],
 `;
-  generated2 += `  const _contentData = new Map<string, ResourceRequest>()
+  generated2 += `  }
 `;
-  if (contentBlockResourceSelections.length > 0) {
-    for (const { source, candidates } of generatedContentSelections) {
-      for (const { assetId: assetId2, resourceIds } of candidates) {
-        generated2 += `  if (${source} === ${JSON.stringify(assetId2)}) {
+  if ([...selectedResourceIds].some(
+    (resourceId2) => graphResourceIds.has(resourceId2)
+  )) {
+    generated2 += `  const _contentDocuments = new Map<string, unknown>([
 `;
-        for (const dataSource2 of dataSources.values()) {
-          if (dataSource2.type !== "resource" || resourceIds.includes(dataSource2.resourceId) === false || generatedResourceIds.has(dataSource2.resourceId) === false || actionResourceIds.has(dataSource2.resourceId)) {
-            continue;
-          }
-          const name2 = scope2.getName(dataSource2.resourceId, dataSource2.name);
-          generated2 += `    _contentData.set(${JSON.stringify(name2)}, ${name2})
+    for (const dataSource2 of usedDataSources.values()) {
+      if (dataSource2.type !== "resource" || contentInputDataSourceIds.has(dataSource2.id) === false) {
+        continue;
+      }
+      const name2 = scope2.getName(dataSource2.id, dataSource2.name);
+      generated2 += `    [${JSON.stringify(dataSource2.resourceId)}, ${name2}],
+`;
+    }
+    generated2 += `  ])
+`;
+  }
+  generated2 += `  const _contentData = new Map<string, ResourceRequest>()
+`;
+  for (const { source, candidates } of generatedContentSelections) {
+    for (const { assetId: assetId2, resourceIds } of candidates) {
+      generated2 += `  if (${source} === ${JSON.stringify(assetId2)}) {
 `;
+      for (const resourceId2 of resourceIds) {
+        const dataSource2 = resourceDataSourceByResourceId.get(resourceId2);
+        if (dataSource2 === void 0 || actionResourceIds.has(resourceId2)) {
+          continue;
         }
-        generated2 += `  }
+        const name2 = scope2.getName(resourceId2, dataSource2.name);
+        const request = graphResourceIds.has(resourceId2) ? `${scope2.getName(resourceId2, resources.get(resourceId2)?.name ?? dataSource2.name)}(_contentDocuments)` : name2;
+        generated2 += `    _contentData.set(${JSON.stringify(name2)}, ${request})
 `;
       }
+      generated2 += `  }
+`;
     }
   }
-  generated2 += `  const _action = new Map<string, ResourceRequest>([
-`;
-  for (const prop2 of props2.values()) {
-    if (prop2.type === "resource" && generatedResourceIds.has(prop2.value)) {
-      const name2 = scope2.getName(prop2.value, prop2.name);
-      generated2 += `    ["${name2}", ${name2}],
+  generated2 += `  const _action = new Map<string, { id: string; outputName: string }>([
 `;
+  for (const prop2 of actionResourceProps) {
+    const resource2 = resources.get(prop2.value);
+    if (resource2 === void 0 || graphResourceIds.has(prop2.value) === false) {
+      continue;
     }
+    const name2 = scope2.getName(prop2.value, prop2.name);
+    const outputName = scope2.getName(prop2.value, resource2.name);
+    generated2 += `    ["${name2}", { id: ${JSON.stringify(
+      prop2.value
+    )}, outputName: ${JSON.stringify(outputName)} }],
+`;
   }
   generated2 += `  ])
 `;
@@ -187039,7 +187507,7 @@ const replaceDataSourcesInExpression = (expression2, replacements) => {
     return expression2;
   }
 };
-const computeExpression = (expression2, variables) => {
+const evaluateExpression = (expression2, variables) => {
   try {
     const proxiedVariables = /* @__PURE__ */ new Map();
     const getVariable = (key2) => {
@@ -187059,8 +187527,43 @@ const computeExpression = (expression2, variables) => {
     return void 0;
   }
 };
-const computeStringExpression = (expression2, variables) => {
-  const value2 = computeExpression(expression2, variables);
+const resolveExpressionVariables = async ({
+  expression: expression2,
+  variables,
+  resolveDataSource
+}) => {
+  const dataSourceIds = /* @__PURE__ */ new Set();
+  for (const identifier2 of getExpressionIdentifiers(expression2)) {
+    const dataSourceId2 = decodeDataVariableId(identifier2);
+    if (dataSourceId2 !== void 0) {
+      dataSourceIds.add(dataSourceId2);
+    }
+  }
+  const resolved = new Map(variables);
+  await Promise.all(
+    [...dataSourceIds].map(async (dataSourceId2) => {
+      resolved.set(
+        dataSourceId2,
+        await resolveDataSource(dataSourceId2, variables.get(dataSourceId2))
+      );
+    })
+  );
+  return resolved;
+};
+const computeExpression = async (expression2, variables, resolveDataSource = (_dataSourceId, value2) => value2) => evaluateExpression(
+  expression2,
+  await resolveExpressionVariables({
+    expression: expression2,
+    variables,
+    resolveDataSource
+  })
+);
+const computeStringExpression = async (expression2, variables, resolveDataSource) => {
+  const value2 = await computeExpression(
+    expression2,
+    variables,
+    resolveDataSource
+  );
   return typeof value2 === "string" && value2 !== "" ? value2 : void 0;
 };
 const getParentInstanceById = (instances) => {
@@ -195783,10 +196286,10 @@ const getFragmentContentModelWarnings = ({
     metas
   });
 };
-const resolveContentBlockSourceAssetId = ({
+const resolveContentBlockSourceAssetId = async ({
   source,
   values
-}) => source.type === "asset" ? source.assetId : values === void 0 ? void 0 : computeStringExpression(source.value, values);
+}) => source.type === "asset" ? source.assetId : values === void 0 ? void 0 : await computeStringExpression(source.value, values);
 const findBlockTemplateNameCollision = ({
   instance: instance2,
   nextInstance,
@@ -281094,18 +281597,6 @@ Any elements that were not used above are used below.
 > [!NOTE]
 > Add helpful context without interrupting the main content.
 
-> [!TIP]
-> Share a useful suggestion.
-
-> [!IMPORTANT]
-> Highlight essential information.
-
-> [!WARNING]
-> Point out something readers should be careful about.
-
-> [!CAUTION]
-> Explain a potential negative consequence.
-
 Using \`console.log("Hello World");\` will log to the console.
 
 | Header 1   | Header 2   | Header 3   |
@@ -281139,29 +281630,6 @@ const meta$i = {
         "ws:style": markdownAlertStyle
       }
     ),
-    /* @__PURE__ */ jsxRuntimeExports.jsx(ws.descendant, { "ws:label": "Note alert", selector: ' [data-state="note"]' }),
-    /* @__PURE__ */ jsxRuntimeExports.jsx(ws.descendant, { "ws:label": "Tip alert", selector: ' [data-state="tip"]' }),
-    /* @__PURE__ */ jsxRuntimeExports.jsx(
-      ws.descendant,
-      {
-        "ws:label": "Important alert",
-        selector: ' [data-state="important"]'
-      }
-    ),
-    /* @__PURE__ */ jsxRuntimeExports.jsx(
-      ws.descendant,
-      {
-        "ws:label": "Warning alert",
-        selector: ' [data-state="warning"]'
-      }
-    ),
-    /* @__PURE__ */ jsxRuntimeExports.jsx(
-      ws.descendant,
-      {
-        "ws:label": "Caution alert",
-        selector: ' [data-state="caution"]'
-      }
-    ),
     /* @__PURE__ */ jsxRuntimeExports.jsx(ws.descendant, { "ws:label": "Code Text", selector: " code" }),
     /* @__PURE__ */ jsxRuntimeExports.jsx(ws.descendant, { "ws:label": "List", selector: " :where(ul, ol)" }),
     /* @__PURE__ */ jsxRuntimeExports.jsx(ws.descendant, { "ws:label": "List Item", selector: " li" }),
@@ -297922,8 +298390,7 @@ const getStaticString = (expression2) => {
   if (isLiteralExpression(expression2) === false) {
     return;
   }
-  const value2 = computeExpression(expression2, /* @__PURE__ */ new Map());
-  return typeof value2 === "string" ? value2 : void 0;
+  return parseStringLiteralExpression(expression2);
 };
 const analyzeProject = (state, input2) => {
   if (state.instances === void 0 || state.props === void 0 || state.styles === void 0 || state.styleSources === void 0 || state.styleSourceSelections === void 0 || state.resources === void 0 || state.dataSources === void 0 || state.assets === void 0 || state.breakpoints === void 0) {
@@ -328066,6 +328533,30 @@ const serverOnlyRouterOperationMetadata = {
       additionalProperties: true
     }
   },
+  "publish.validate": {
+    id: "publish.validate",
+    command: "check-publish-readiness",
+    method: "query",
+    path: "api.publish.validate",
+    client: "checkPublishReadiness",
+    permit: "edit",
+    inputSchema: {
+      type: "object",
+      properties: {
+        target: {
+          type: "string",
+          enum: ["staging", "production"]
+        },
+        domains: {
+          type: "array",
+          items: {
+            type: "string"
+          }
+        }
+      },
+      required: ["target"]
+    }
+  },
   "publish.list": {
     id: "publish.list",
     command: "list-publishes",
@@ -329018,6 +329509,15 @@ const curatedPublicApiOperationDocumentation = [
     requiredOptions: ["resource", "json"],
     examples: ["webstudio delete-resource --resource resource-id --json"]
   },
+  {
+    command: "check-publish-readiness",
+    description: "Check publish access, selected domains, and content diagnostics without starting a publish. Use audit for project-wide quality checks.",
+    requiredOptions: ["target", "json"],
+    examples: [
+      "webstudio check-publish-readiness --target production --json",
+      'MCP tool: check-publish-readiness {"target":"production"}'
+    ]
+  },
   {
     command: "publish",
     description: "Publish the configured project to staging or production. Uses the project domain by default and, for production, active verified custom domains. If local development cannot contact the deployment backend, the JSON response includes warning while still returning the local publish job id.",
@@ -330863,6 +331363,7 @@ const createResource = projectMutationInput("create-resource");
 const updateResource = projectMutationInput("update-resource");
 const deleteResource = projectMutationInput("delete-resource");
 const listPublishes = projectQueryInput("list-publishes");
+const checkPublishReadiness = projectQueryInput("check-publish-readiness");
 const publish = projectMutationInput("publish");
 const getPublishJob = projectQueryInput("get-publish-job");
 const unpublish = projectConfirmedMutationInput("unpublish");
@@ -331027,6 +331528,7 @@ const httpClient = /* @__PURE__ */ Object.freeze(/* @__PURE__ */ Object.definePr
   bindProps,
   bundleVersion,
   checkProjectBuildPermission,
+  checkPublishReadiness,
   clearStyleSourceStyles,
   cloneInstance,
   connectContentBlockSource,
@@ -331219,7 +331721,7 @@ class HandledCliError extends Error {
 }
 const isHandledCliError = (error) => error instanceof HandledCliError;
 const name = "webstudio";
-const version$1 = "0.299.0";
+const version$1 = "0.300.0";
 const description = "Webstudio CLI";
 const author = "Webstudio <github@webstudio.is>";
 const homepage = "https://webstudio.is";
@@ -338207,7 +338709,7 @@ const bindContentBlockSource = (state, blockInstanceId, source) => source.type =
   ...source,
   value: bindExpressionInput(state, blockInstanceId, source.value)
 } : source;
-const getMdxAssetSourceBlockInstanceIds = ({
+const getMdxAssetSourceBlockInstanceIds = async ({
   assetId: assetId2,
   state
 }) => {
@@ -338218,13 +338720,21 @@ const getMdxAssetSourceBlockInstanceIds = ({
       values.set(dataSource2.id, dataSource2.value.value);
     }
   }
-  return Array.from(
-    getContentBlockSources({
-      instances: state.instances?.values() ?? [],
-      props: state.props?.values() ?? []
-    })
-  ).flatMap(
-    ([blockInstanceId, contentSource]) => resolveContentBlockSourceAssetId({ source: contentSource, values }) === assetId2 ? [blockInstanceId] : []
+  const blockInstanceIds = await Promise.all(
+    Array.from(
+      getContentBlockSources({
+        instances: state.instances?.values() ?? [],
+        props: state.props?.values() ?? []
+      })
+    ).map(
+      async ([blockInstanceId, contentSource]) => await resolveContentBlockSourceAssetId({
+        source: contentSource,
+        values
+      }) === assetId2 ? blockInstanceId : void 0
+    )
+  );
+  return blockInstanceIds.filter(
+    (blockInstanceId) => blockInstanceId !== void 0
   );
 };
 const mdxAssetInspectionNamespaces = componentInsertReadNamespaces;
@@ -338276,7 +338786,7 @@ const inspectMdxAssetSource = async ({
   }
   const data2 = getData(state);
   const blockInstanceIds = /* @__PURE__ */ new Set([
-    ...getMdxAssetSourceBlockInstanceIds({ assetId: assetId2, state }),
+    ...await getMdxAssetSourceBlockInstanceIds({ assetId: assetId2, state }),
     ...sourceBlockInstanceIds
   ]);
   for (const blockInstanceId of blockInstanceIds) {
@@ -338319,13 +338829,13 @@ const createContentBlockApplication = ({
   metas,
   resolveSourceAssetId
 }) => {
-  const resolveSource = ({
+  const resolveSource = async ({
     source,
     state,
     blockInstanceId,
     variables
   }) => {
-    const resolved = resolveSourceAssetId?.({ source, state, variables });
+    const resolved = await resolveSourceAssetId?.({ source, state, variables });
     if (resolveSourceAssetId !== void 0) {
       if (resolved === void 0 || resolved === "") {
         throw new Error("Content source does not resolve to an MDX Asset");
@@ -338347,11 +338857,11 @@ const createContentBlockApplication = ({
         values.set(dataSource2.id, dataSource2.value.value);
       }
     }
-    const assetId2 = resolveContentBlockSourceAssetId({ source, values });
+    const assetId2 = await resolveContentBlockSourceAssetId({ source, values });
     if (assetId2 !== void 0) {
       return assetId2;
     }
-    const evaluated = source.type === "expression" ? computeExpression(source.value, values) : void 0;
+    const evaluated = source.type === "expression" ? await computeExpression(source.value, values) : void 0;
     const suppliedVariableShapes = Object.entries(variables ?? {}).map(
       ([name2, value2]) => `${JSON.stringify(name2)} (${describeValueShape(value2)})`
     ).join(", ") || "none";
@@ -338382,7 +338892,7 @@ const createContentBlockApplication = ({
     renderScope,
     variables
   }) => {
-    const assetId2 = resolveSource({
+    const assetId2 = await resolveSource({
       source,
       state,
       blockInstanceId,
@@ -344719,6 +345229,41 @@ const appRoot = "app";
 const generatedDir = join$2(appRoot, "__generated__");
 const routesDir = join$2(appRoot, "routes");
 const generatedOutputDirectories = [generatedDir, routesDir];
+const hydrateLocalMarkdownContents = async ({
+  artifact,
+  assets,
+  assetsDirectory,
+  includeMarkdown
+}) => {
+  const assetsById = new Map(assets.map((asset2) => [asset2.id, asset2]));
+  const missingContents = await Promise.all(
+    artifact.documents.filter(
+      (document2) => (document2.extension === "mdx" || includeMarkdown && document2.extension === "md") && document2.contentRef !== void 0 && artifact.contents?.[document2.contentRef] === void 0
+    ).map(async (document2) => {
+      const asset2 = assetsById.get(document2._id);
+      if (asset2 === void 0) {
+        return;
+      }
+      const content2 = await readFile(
+        getLocalAssetPath(asset2.name, assetsDirectory),
+        "utf8"
+      ).catch(() => void 0);
+      return content2 === void 0 ? void 0 : [document2.contentRef, content2];
+    })
+  );
+  const contents = Object.fromEntries(
+    missingContents.filter(
+      (entry2) => entry2 !== void 0
+    )
+  );
+  return Object.keys(contents).length === 0 ? artifact : {
+    ...artifact,
+    contents: {
+      ...artifact.contents,
+      ...contents
+    }
+  };
+};
 const getBoundSystemRouteParameter = (expression2) => {
   const path2 = parseStaticMemberPath(expression2);
   const variable2 = path2?.[0];
@@ -344892,7 +345437,9 @@ const getAssetResourcePrerenderPaths = ({
     );
     if (completeRouteConfigurations.length > 0 && enumerableConfigurations.length === 0) {
       throw new Error(
-        `Dynamic SSG route parameter ${JSON.stringify(firstUnenumerableParameter)} cannot be completely enumerated from every Assets query branch`
+        `Dynamic SSG route parameter ${JSON.stringify(
+          firstUnenumerableParameter
+        )} cannot be completely enumerated from every Assets query branch`
       );
     }
   }
@@ -344939,7 +345486,9 @@ const getAssetResourcePrerenderPaths = ({
         for (const match of [...pathParameters].reverse()) {
           const name2 = match.groups?.name;
           const value2 = values.get(name2);
-          path2 = `${path2.slice(0, match.index)}${encodeURIComponent(value2)}${path2.slice((match.index ?? 0) + match[0].length)}`;
+          path2 = `${path2.slice(0, match.index)}${encodeURIComponent(
+            value2
+          )}${path2.slice((match.index ?? 0) + match[0].length)}`;
         }
         paths.add(path2);
         if (paths.size > assetResourceLimits.candidateDocuments) {
@@ -345026,18 +345575,19 @@ const createRuntimeFetch = createGeneratedAssetResourceRuntime({
   runtimeAssets,
 });
 
-export const createGeneratedAssetResourceFetch = ({ request, fallback }: ${inputType}) =>
-  createRuntimeFetch({ request, fallback });
+export const createGeneratedAssetResourceFetch = ({ request, context, fallback }: ${inputType}) =>
+  createRuntimeFetch({ request, context, fallback });
 `;
 };
 const materializeVerifiedAssetIndex = async ({
   index: index2,
   runtimeAssets,
   includeDocumentRuntimeAssets,
+  includeContents,
   generatedDirectory,
   deploymentId
 }) => {
-  const runtimeIndex = index2 === void 0 ? void 0 : createContentRuntimeArtifact(index2);
+  const runtimeIndex = index2 === void 0 ? void 0 : createContentRuntimeArtifact(index2, { includeContents });
   const serializedIndex = runtimeIndex === void 0 ? void 0 : serializeContentRuntimeArtifact(runtimeIndex);
   const runtimeAssetIds = runtimeIndex === void 0 ? [] : getContentRuntimeArtifactRuntimeAssetIds({
     artifact: runtimeIndex,
@@ -345260,8 +345810,9 @@ Please check webstudio --help for more details`
     preserveTemplates: preserveRouteTemplates,
     templatesDirectory: join$2(buildRoot, routeTemplatesDirectory)
   };
+  const isStaticBuild = options.template.includes("ssg");
   let framework;
-  if (options.template.includes("ssg")) {
+  if (isStaticBuild) {
     framework = await createFramework(frameworkOptions);
   } else if (options.template.includes("react-router")) {
     framework = await createFramework$1(frameworkOptions);
@@ -345294,7 +345845,17 @@ Please check webstudio --help for more details`
   const siteData = parsedSiteData.data;
   const pages2 = migratePages(siteData.build.pages);
   const publicationBuild = { ...siteData.build, pages: pages2 };
-  const verifiedAssetIndex = siteData.assetIndex === void 0 ? void 0 : await verifyContentArtifact(siteData.assetIndex);
+  let verifiedAssetIndex = siteData.assetIndex === void 0 ? void 0 : await verifyContentArtifact(siteData.assetIndex);
+  if (verifiedAssetIndex !== void 0 && (options.previewIdentity === true || options.assets === true)) {
+    verifiedAssetIndex = await hydrateLocalMarkdownContents({
+      artifact: verifiedAssetIndex,
+      assets: siteData.assets,
+      assetsDirectory: options.sourceAssetsDirectory ?? join$2(buildRoot, LOCAL_ASSETS_DIR),
+      // SSR only needs local MDX sources during component compilation. Its
+      // runtime reads article contents over HTTP, just like hosted sites.
+      includeMarkdown: isStaticBuild
+    });
+  }
   let dynamicMdxCandidates;
   if (hasDynamicPublishedMdxSources(publicationBuild)) {
     dynamicMdxCandidates = verifiedAssetIndex === void 0 ? /* @__PURE__ */ new Map() : resolvePublishedMdxAssetCandidates({
@@ -345414,7 +345975,7 @@ Please check webstudio --help for more details`
       asset2,
       "https://placeholder.local"
     );
-    return siteData.build.deployment?.destination === "saas" && options.assets === false ? runtimeAsset.url : `${assetBaseUrl}${asset2.name}`;
+    return isPublishedDeployment(siteData.build.deployment) && options.assets === false ? runtimeAsset.url : `${assetBaseUrl}${asset2.name}`;
   };
   const runtimeAssetsById = Object.fromEntries(
     siteData.assets.map((asset2) => {
@@ -345427,8 +345988,9 @@ Please check webstudio --help for more details`
         {
           ...runtimeAsset,
           contentRef: asset2.name,
-          // SaaS serves project assets through its storage-backed proxy.
-          // Generated projects with downloaded assets serve them locally.
+          // Hosted deployments serve project assets through storage-backed
+          // proxies. Generated projects with downloaded assets serve them
+          // locally.
           url: getPublishedAssetUrl(asset2)
         }
       ];
@@ -345800,7 +346362,9 @@ Please check webstudio --help for more details`
     for (const contribution of componentBuildContributions.values()) {
       for (const buildImport of contribution.imports) {
         if (buildImport.imported === void 0) {
-          importsString += `import ${buildImport.local} from ${JSON.stringify(buildImport.source)};
+          importsString += `import ${buildImport.local} from ${JSON.stringify(
+            buildImport.source
+          )};
 `;
         } else {
           importsString += `import { ${buildImport.imported} as ${buildImport.local} } from ${JSON.stringify(buildImport.source)};
@@ -345930,6 +346494,7 @@ Please check webstudio --help for more details`
       dataSources,
       props: props2,
       resources,
+      instances,
       contentBlockResourceSelections: Array.from(
         pageData.publishedContentBlocks?.values() ?? []
       ).flatMap(
@@ -346019,13 +346584,20 @@ Please check webstudio --help for more details`
   await writeGeneratedFile(
     join$2(generatedDir, "$resources.sitemap.xml.ts"),
     `
-      export const sitemap: Array<{ path: string; lastModified: string }> = ${JSON.stringify(sitemap, null, 2)};
+      export const sitemap: Array<{ path: string; lastModified: string }> = ${JSON.stringify(
+      sitemap,
+      null,
+      2
+    )};
     `
   );
   await materializeVerifiedAssetIndex({
     index: verifiedAssetIndex,
     runtimeAssets: runtimeAssetsById,
     includeDocumentRuntimeAssets: assetCompilationPlan !== void 0 && requiresRuntimeDocumentData(assetCompilationPlan),
+    // Only static prerendering consumes embedded source files. Both local
+    // and hosted SSR use the same HTTP content loader and serve assets.
+    includeContents: isStaticBuild,
     generatedDirectory: generatedDir,
     deploymentId: siteData.build.id
   });
@@ -348475,6 +349047,7 @@ const publishCommandOptions = (yargs) => publishDomainsOption(publishTargetOptio
   type: "string",
   describe: "Optional idempotency key for retrying the same publish"
 });
+const checkPublishReadinessCommandOptions = (yargs) => publishDomainsOption(publishTargetOption(apiCommandOptions(yargs)));
 const publishJobCommandOptions = (yargs) => apiCommandOptions(yargs).option("job", {
   type: "string",
   describe: "Required publish job id returned by publish or unpublish",
@@ -349884,6 +350457,18 @@ const apiCommandHandlers = {
     };
     return runProjectSessionCommand("publish", input2, connection, dependencies2);
   },
+  "check-publish-readiness": async (options, connection, dependencies2) => {
+    const input2 = {
+      target: publishTargetValue(options.target),
+      domains: listStringOption(options.domain)
+    };
+    return runProjectSessionCommand(
+      "check-publish-readiness",
+      input2,
+      connection,
+      dependencies2
+    );
+  },
   "list-publishes": async (options, connection, dependencies2) => runProjectSessionCommand(
     "list-publishes",
     {
@@ -350332,6 +350917,7 @@ const apiCommandOptionsByCommand = {
   "delete-resource": deleteResourceCommandOptions,
   "list-domains": paginatedListCommandOptions,
   publish: publishCommandOptions,
+  "check-publish-readiness": checkPublishReadinessCommandOptions,
   "get-publish-job": publishJobCommandOptions,
   unpublish: unpublishCommandOptions,
   "create-domain": createDomainCommandOptions,
@@ -350363,6 +350949,10 @@ const apiCommandMetadata = publicApiOperations.map((operation) => ({
 }));
 const highLevelCliCommands = [
   { command: "audit", operation: "audit" },
+  {
+    command: "check-publish-readiness",
+    operation: "check-publish-readiness"
+  },
   { command: "permissions", operation: "permissions" },
   { command: "get-assets-resource", operation: "get-assets-resource" },
   { command: "create-assets-resource", operation: "create-assets-resource" },
@@ -350915,7 +351505,7 @@ const apiCommandsByArea = {
   projectQuality: cliCommandMetadata.filter(({ cliCommand }) => cliCommand === "audit").map(({ cliCommand }) => cliCommand),
   assetsAndIndexes: cliCommandMetadata.filter(({ cliCommand }) => cliCommand.includes("asset")).map(({ cliCommand }) => cliCommand),
   publishAndDomains: cliCommandMetadata.filter(
-    ({ cliCommand }) => cliCommand.startsWith("publish ") || cliCommand.startsWith("domains ")
+    ({ cliCommand }) => cliCommand === "check-publish-readiness" || cliCommand.startsWith("publish ") || cliCommand.startsWith("domains ")
   ).map(({ cliCommand }) => cliCommand),
   pagesAndSettings: cliCommandMetadata.filter(
     ({ cliCommand }) => [