@projectdochelp/s3te 3.2.1 → 3.2.3

package/README.md

@@ -17,7 +17,8 @@ This README is the user guide for the rewrite generation. The deeper implementat
   - [Usage](#usage)
     - [Daily Workflow](#daily-workflow)
     - [CLI Commands](#cli-commands)
-    - [Template Commands](#template-commands)
+  - [Template Commands](#template-commands)
+  - [Optional: Sitemap](#optional-sitemap)
   - [Optional: Webiny CMS](#optional-webiny-cms)
 
 ## Motivation
@@ -65,6 +66,8 @@ That source sync is not limited to Lambda code. It includes your `.html`, `.part
 
 The persistent environment stack contains the long-lived AWS resources such as buckets, Lambda functions, DynamoDB tables, CloudFront distributions and the runtime manifest parameter. The temporary deploy stack exists only so CloudFormation can consume the packaged Lambda artifacts cleanly.
 
+If optional runtime features such as `sitemap` or Webiny are enabled in `s3te.config.json`, the same environment stack also carries those extra Lambdas and event bindings.
+
 </details>
 
 ## Installation (AWS)
@@ -226,13 +229,18 @@ The most important fields for a first deployment are:
 
 `route53HostedZoneId` is optional. Leave it out if you want to manage DNS yourself.
 
-Use plain hostnames in `baseUrl` and `cloudFrontAliases`, not full URLs. If your config contains a `prod` environment plus additional environments such as `test` or `stage`, S3TE keeps the `prod` hostname unchanged and derives non-production hostnames automatically by prepending `<env>.`.
+Use plain hostnames in `baseUrl` and `cloudFrontAliases`, not full URLs. If your config contains a `prod` environment plus additional environments such as `test` or `stage`, S3TE keeps the `prod` hostname unchanged and derives non-production hostnames like this:
+
+- apex host: `example.com` -> `test.example.com`
+- first-level subdomain: `app.example.com` -> `test-app.example.com`
+- deeper host: `admin.app.example.com` -> `test-admin.app.example.com`
 
 Your ACM certificate must cover the final derived aliases of the environment you deploy. Example:
 
 - `*.example.com` covers `test.example.com`
-- `*.example.com` does not cover `test.app.example.com`
-- for nested aliases like `test.app.example.com`, add a SAN such as `*.app.example.com`, the exact hostname, or use a different `certificateArn` for that environment
+- `*.example.com` also covers `test-app.example.com`
+- `*.example.com` does not cover `test-admin.app.example.com`
+- for deeper aliases like `test-admin.app.example.com`, add a SAN such as `*.app.example.com`, the exact hostname, or use a different `certificateArn` for that environment
 
 </details>
 
@@ -476,31 +484,86 @@ Once Webiny is installed and the stack is deployed with Webiny enabled, CMS cont
 | `s3te sync --env <name>` | Uploads current project sources into the configured code buckets. |
 | `s3te doctor --env <name>` | Checks local machine and AWS access before deploy. |
 | `s3te deploy --env <name>` | Deploys or updates the AWS environment and syncs source files. |
-| `s3te migrate` | Updates older project configs and can retrofit Webiny into an existing S3TE project. |
+| `s3te migrate` | Updates older project configs and can retrofit optional features such as `sitemap` or Webiny into an existing S3TE project. |
 
 </details>
 
-### Template Commands
+## Template Commands
+
+S3TE uses literal HTML-like tags inside your `.html` and `.part` files. The tags are case-sensitive, always lowercase, and never use attributes. JSON-based commands must contain valid JSON and reject unknown properties.
+
+The commands below are grouped by purpose:
 
-These are the core S3TE commands you will use even in a plain HTML-only project.
+- `Core Features` work in every S3TE project.
+- `Webiny Features` are the content-driven commands. Despite the name, they also work with local content files under `offline/content/` when you are not using Webiny yet.
+
+### Core Features
 
 <details>
-  <summary><code>&lt;part&gt;</code> - reuse a partial file</summary>
+  <summary><code>&lt;part&gt;</code> - reuse a partial file from <code>partDir</code></summary>
+
+**Action**
+
+Loads another template fragment from the current variant's `partDir`, renders it recursively, and inserts the result at the current position.
+
+**Syntax**
 
 ```html
 <part>head.part</part>
 ```
 
+The payload must be a relative path inside `partDir`. Leading `/` and `..` are invalid.
+
+**Example**
+
+```html
+<head>
+  <part>head.part</part>
+</head>
+```
+
 </details>
 
 <details>
   <summary><code>&lt;if&gt;</code> - render inline HTML only when a condition matches</summary>
 
+**Action**
+
+Evaluates one inline JSON rule and renders its `template` only when the rule matches the current render target.
+
+**Syntax**
+
+```html
+<if>{
+  "env": "prod",
+  "file": "index.html",
+  "not": false,
+  "template": "<meta name='robots' content='all'>"
+}</if>
+```
+
+Supported JSON properties:
+
+- `env` optional: matches the current environment name case-insensitively
+- `file` optional: matches the current output filename, for example `index.html`
+- `not` optional: inverts the final result when `true`
+- `template` required: inline HTML to render when the rule matches
+
+If both `env` and `file` are present, both must match.
+
+If both conditions are omitted, the tag behaves like an inline template include and always renders its `template`.
+
+**Example**
+
 ```html
 <if>{
   "env": "prod",
   "template": "<meta name='robots' content='all'>"
 }</if>
+<if>{
+  "env": "test",
+  "template": "<meta name='robots' content='noindex'>"
+}</if>
 ```
 
 </details>
@@ -508,18 +571,55 @@ These are the core S3TE commands you will use even in a plain HTML-only project.
 <details>
   <summary><code>&lt;fileattribute&gt;</code> - print metadata of the current output file</summary>
 
+**Action**
+
+Prints metadata of the file currently being rendered.
+
+**Syntax**
+
 ```html
 <fileattribute>filename</fileattribute>
 ```
 
+Currently supported values:
+
+- `filename`: the output key relative to the target bucket, for example `news/article-one.html`
+
+**Example**
+
+```html
+<link rel="canonical" href="https://<lang>baseurl</lang>/<fileattribute>filename</fileattribute>">
+```
+
 </details>
 
 <details>
-  <summary><code>&lt;lang&gt;</code> - print the current language metadata</summary>
+  <summary><code>&lt;lang&gt;</code> - print current language metadata</summary>
+
+**Action**
+
+Prints language-related metadata of the current render target.
+
+**Syntax**
+
+```html
+<lang>2</lang>
+<lang>baseurl</lang>
+```
+
+Currently supported values:
+
+- `2`: the current language code such as `en` or `de`
+- `baseurl`: the resolved base hostname for the current language and environment
+
+**Example**
 
 ```html
 <html lang="<lang>2</lang>">
-<link rel="canonical" href="https://<lang>baseurl</lang>">
+  <head>
+    <link rel="canonical" href="https://<lang>baseurl</lang>">
+  </head>
+</html>
 ```
 
 </details>
@@ -527,6 +627,12 @@ These are the core S3TE commands you will use even in a plain HTML-only project.
 <details>
   <summary><code>&lt;switchlang&gt;</code> - choose inline content by language</summary>
 
+**Action**
+
+Selects the block whose tag name matches the current language and renders only that block.
+
+**Syntax**
+
 ```html
 <switchlang>
   <de>Willkommen</de>
@@ -534,9 +640,327 @@ These are the core S3TE commands you will use even in a plain HTML-only project.
 </switchlang>
 ```
 
+There is no fallback to `defaultLanguage`. If the current language block is missing, S3TE renders an empty string and records a warning.
+
+**Example**
+
+```html
+<p>
+  <switchlang>
+    <de>Dein ultimatives Website-Werkzeug</de>
+    <en>Your ultimate website tool</en>
+  </switchlang>
+</p>
+```
+
+</details>
+
+### Webiny Features
+
+These commands read from the resolved content repository. With Webiny enabled, that means mirrored Webiny content. Without Webiny, the same commands can read from local JSON files under `offline/content/`.
+
+<details>
+  <summary><code>&lt;dbpart&gt;</code> - insert one content fragment by <code>contentId</code></summary>
+
+**Action**
+
+Loads a single content item by `contentId` and inserts its content fragment.
+
+S3TE first tries the language-specific field `content&lt;lang&gt;`, for example `contentde`, and falls back to `content` if the language-specific field does not exist.
+
+**Syntax**
+
+```html
+<dbpart>impressum</dbpart>
+```
+
+The payload is the content ID, not the internal database record ID.
+
+**Example**
+
+```html
+<body>
+  <dbpart>impressum</dbpart>
+</body>
+```
+
+</details>
+
+<details>
+  <summary><code>&lt;dbmulti&gt;</code> - render one inline template for multiple content items</summary>
+
+**Action**
+
+Queries matching content items and renders the given inline template once for each result.
+
+**Syntax**
+
+```html
+<dbmulti>{
+  "filter": [
+    {"forWebsite": {"BOOL": true}}
+  ],
+  "filtertype": "equals",
+  "limit": 3,
+  "template": "<article><h2><dbitem>headline</dbitem></h2></article>"
+}</dbmulti>
+```
+
+Supported JSON properties:
+
+- `filter` required: array of legacy DynamoDB-style filter clauses
+- `filtertype` optional: `equals` or `contains`, default is `equals`
+- `limit` optional: maximum number of items to render
+- `template` required: inline template rendered once per match
+
+Filter notes:
+
+- every filter clause contains exactly one field
+- multiple clauses are combined with logical `AND`
+- `__typename` matches the content model, for example `article`
+- supported legacy value wrappers are `S`, `N`, `BOOL`, `NULL`, and `L`
+- results are sorted deterministically; numeric `order` comes first, then `contentId`, then `id`
+
+**Example**
+
+```html
+<dbmulti>{
+  "filter": [
+    {"__typename": {"S": "article"}},
+    {"forWebsite": {"BOOL": true}}
+  ],
+  "limit": 3,
+  "template": "<a href='article-<dbitem>slug</dbitem>.html'><h2><dbitem>headline</dbitem></h2></a>"
+}</dbmulti>
+```
+
+</details>
+
+<details>
+  <summary><code>&lt;dbmultifile&gt;</code> - generate one output file per content item</summary>
+
+**Action**
+
+Turns one source template into multiple output files. The content items are selected by filter, and each item produces one rendered file.
+
+**Syntax**
+
+```html
+<dbmultifile>{
+  "filenamesuffix": "slug",
+  "filter": [
+    {"__typename": {"S": "article"}}
+  ],
+  "limit": 10
+}</dbmultifile>
+<!doctype html>
+<html>
+  <body>
+    <h1><dbmultifileitem>headline</dbmultifileitem></h1>
+  </body>
+</html>
+```
+
+Supported JSON properties:
+
+- `filenamesuffix` required: field whose value becomes the filename suffix
+- `filter` required: array of legacy DynamoDB-style filter clauses
+- `filtertype` optional: `equals` or `contains`, default is `equals`
+- `limit` optional: maximum number of files to generate
+
+Rules:
+
+- `dbmultifile` must be the first non-whitespace construct in the file
+- the control block itself is not part of the output
+- generated filenames follow the pattern `<basename>-<suffix>.<ext>`
+- the suffix must not be empty and must not contain `/`, `\\`, or `:`
+- suffixes must be unique within that template
+
+**Example**
+
+If the source file is `article.html` and the current item has `"slug": "first-article"`, the generated output becomes `article-first-article.html`.
+
+```html
+<dbmultifile>{
+  "filenamesuffix": "slug",
+  "filter": [
+    {"__typename": {"S": "article"}}
+  ]
+}</dbmultifile>
+<article>
+  <h1><dbmultifileitem>headline</dbmultifileitem></h1>
+</article>
+```
+
+</details>
+
+<details>
+  <summary><code>&lt;dbitem&gt;</code> - print one field of the current content item</summary>
+
+**Action**
+
+Reads one field from the current content item. This works inside `dbmulti` templates and inside `dbmultifile` bodies.
+
+**Syntax**
+
+```html
+<dbitem>headline</dbitem>
+```
+
+Special field names:
+
+- `__typename`
+- `contentId`
+- `id`
+- `locale`
+- `tenant`
+- `_version`
+- `_lastChangedAt`
+
+For the field name `content`, S3TE again prefers `content&lt;lang&gt;` over `content`.
+
+If the field value is a string array, S3TE serializes it as concatenated HTML links.
+
+**Example**
+
+```html
+<dbmulti>{
+  "filter": [{"__typename": {"S": "article"}}],
+  "template": "<article><h2><dbitem>headline</dbitem></h2><div><dbitem>content</dbitem></div></article>"
+}</dbmulti>
+```
+
+</details>
+
+<details>
+  <summary><code>&lt;dbmultifileitem&gt;</code> - print or transform fields inside a <code>dbmultifile</code> body</summary>
+
+**Action**
+
+Reads one field from the current content item and can apply one transformation mode. It is primarily meant for `dbmultifile` bodies, but works wherever a current content item exists.
+
+**Syntax**
+
+Simple field output:
+
+```html
+<dbmultifileitem>headline</dbmultifileitem>
+```
+
+JSON command mode:
+
+```html
+<dbmultifileitem>{"field":"content","limit":160}</dbmultifileitem>
+```
+
+Supported JSON properties:
+
+- `field` required
+- `limit` optional: truncate text to a maximum length and append `...`
+- `limitlow` optional: choose a random length between `limitlow` and `limit`
+- `format` optional: currently only `date`
+- `locale` optional: used with `format: "date"`
+- `divideattag` optional: cut a section out of the field value
+- `startnumber` optional: 1-based occurrence number for the divide start
+- `endnumber` optional: 1-based occurrence number for the divide end
+
+Only one transform mode is allowed at a time:
+
+- limit mode: `limit` with optional `limitlow`
+- date mode: `format: "date"`
+- divide mode: `divideattag`
+
+Date mode formats `de` as `dd.mm.yyyy`. All other locales currently format as `mm/dd/yyyy`.
+
+**Examples**
+
+Simple field output:
+
+```html
+<dbmultifileitem>headline</dbmultifileitem>
+```
+
+Truncated teaser text:
+
+```html
+<dbmultifileitem>{"field":"content","limit":160}</dbmultifileitem>
+```
+
+Date formatting:
+
+```html
+<dbmultifileitem>{"field":"publishedAt","format":"date","locale":"de"}</dbmultifileitem>
+```
+
+Extract one section from a larger HTML field:
+
+```html
+<dbmultifileitem>{
+  "field":"content",
+  "divideattag":"<h2>",
+  "startnumber":2,
+  "endnumber":3
+}</dbmultifileitem>
+```
+
+</details>
+
+## Optional: Sitemap
+
+You do not need `sitemap.xml` automation to use S3TE. If you want it, S3TE can maintain one `sitemap.xml` per published output bucket through a dedicated Lambda, just like the older 2.x generation.
+
+<details>
+  <summary>Enable sitemap maintenance</summary>
+
+Add this block to `s3te.config.json`:
+
+```json
+"integrations": {
+  "sitemap": {
+    "enabled": true,
+    "environments": {
+      "dev": {
+        "enabled": false
+      }
+    }
+  }
+}
+```
+
+The top-level `enabled` acts as the default. `integrations.sitemap.environments.<env>.enabled` can override that for a single environment.
+
+If you prefer the CLI path, this does the same retrofit:
+
+```bash
+npx s3te migrate --enable-sitemap --write
+npx s3te migrate --env test --enable-sitemap --write
+```
+
+After enabling or disabling `sitemap`, redeploy the affected environment once:
+
+```bash
+npx s3te deploy --env prod
+```
+
 </details>
 
-If you also want content-driven commands such as `dbmulti` or `dbmultifile`, continue with the optional Webiny section below. The same commands can also read from local `offline/content/*.json` files when you are not using Webiny yet.
+<details>
+  <summary>What the sitemap feature does</summary>
+
+When `sitemap` is enabled for an environment, S3TE adds one `sitemap-updater` Lambda to that environment stack and wires every output bucket to it for HTML create/delete events.
+
+The Lambda maintains `sitemap.xml` directly inside the same output bucket:
+
+- one sitemap per variant/language output bucket
+- only published HTML files are tracked
+- `404.html` is ignored
+- `index.html` becomes `https://example.com/`
+- nested `news/index.html` becomes `https://example.com/news/`
+- regular pages such as `about.html` stay `https://example.com/about.html`
+
+Because the trigger sits on the output bucket, the sitemap also stays correct when HTML is regenerated from Webiny content changes in AWS. Asset-only changes do not affect it.
+
+</details>
 
 ## Optional: Webiny CMS
 
@@ -544,6 +968,8 @@ You do not need Webiny to use S3TE. Start with plain HTML first. Add Webiny only
 
 The supported target for this optional path is Webiny 6.x on its standard AWS deployment model.
 
+Important for the Webiny path: S3TE does not turn on DynamoDB Streams on your Webiny table for you. You must enable the stream manually on the Webiny source table. S3TE uses that stream as the trigger source for CMS-driven rerendering.
+
 ![S3TE with Webiny](https://user-images.githubusercontent.com/100029932/174443536-7af050de-eea7-4456-81aa-a173863b6ec9.png)
 
 <details>
@@ -560,7 +986,10 @@ This section assumes that S3TE is already installed and deployed. The S3TE-speci
 
 1. Install Webiny in AWS and finish the Webiny setup first.
 2. Find the Webiny DynamoDB table that contains the CMS entries you want S3TE to mirror.
-3. Upgrade your existing S3TE config for Webiny:
+3. Manually enable DynamoDB Streams on that Webiny table before the first S3TE deploy with Webiny enabled.
+   Use `NEW_AND_OLD_IMAGES`.
+   Without that stream, `s3te deploy --env <name>` cannot wire the Webiny trigger and fails because the table has no `LatestStreamArn`.
+4. Upgrade your existing S3TE config for Webiny:
 
 ```bash
 npx s3te migrate --enable-webiny --webiny-source-table webiny-1234567 --webiny-tenant root --webiny-model article --write
@@ -568,6 +997,22 @@ npx s3te migrate --enable-webiny --webiny-source-table webiny-1234567 --webiny-t
 
 `staticContent` and `staticCodeContent` are kept automatically. Add `--webiny-model` once per custom model you want S3TE to mirror.
 
+`--webiny-model article` means:
+
+- `article` is the technical Webiny model ID, not the human-readable label shown in the CMS UI.
+- S3TE adds that model ID to `integrations.webiny.relevantModels` in `s3te.config.json`.
+- Only Webiny stream records whose model is listed in `relevantModels` are mirrored into the S3TE content table and can trigger rerendering.
+- If you omit `--webiny-model`, only the built-in defaults `staticContent` and `staticCodeContent` are mirrored.
+- You can pass the flag multiple times for multiple models, for example `--webiny-model article --webiny-model news --webiny-model event`.
+
+That makes the migration example above equivalent to a config that contains:
+
+```json
+"relevantModels": ["article", "staticContent", "staticCodeContent"]
+```
+
+Use this for every Webiny model whose entries should be available to S3TE template commands like `dbitem`, `dbmulti`, `dbmultifile`, `dbmultifileitem`, or `dbpart`.
+
 If different environments should read from different Webiny installations or tenants, run the migration per environment:
 
 ```bash
@@ -575,16 +1020,18 @@ npx s3te migrate --env test --enable-webiny --webiny-source-table webiny-test-12
 npx s3te migrate --env prod --enable-webiny --webiny-source-table webiny-live-1234567 --webiny-tenant root --write
 ```
 
-4. Turn on DynamoDB Streams for the Webiny source table with `NEW_AND_OLD_IMAGES`.
-5. If your S3TE language keys are not identical to your Webiny locales, add `webinyLocale` per language in `s3te.config.json`, for example `"en": { "webinyLocale": "en-US" }`.
-6. If your Webiny installation hosts multiple tenants, keep `integrations.webiny.tenant` set so S3TE only mirrors the intended tenant.
-7. Check the project again:
+5. Verify again that DynamoDB Streams are enabled on the Webiny source table with `NEW_AND_OLD_IMAGES`.
+   You enable this manually in the AWS console on the Webiny DynamoDB table under `Exports and streams`.
+   S3TE creates the Lambda event source mapping during deploy, but it does not create or enable the table stream itself.
+6. If your S3TE language keys are not identical to your Webiny locales, add `webinyLocale` per language in `s3te.config.json`, for example `"en": { "webinyLocale": "en-US" }`.
+7. If your Webiny installation hosts multiple tenants, keep `integrations.webiny.tenant` set so S3TE only mirrors the intended tenant.
+8. Check the project again:
 
 ```bash
 npx s3te doctor --env prod
 ```
 
-8. Redeploy the existing S3TE environment:
+9. Redeploy the existing S3TE environment:
 
 ```bash
 npx s3te deploy --env prod
@@ -592,6 +1039,11 @@ npx s3te deploy --env prod
 
 That deploy updates the existing environment stack and adds the Webiny mirror resources to it. You do not need a fresh S3TE installation. After that, Webiny content changes flow through the deployed AWS resources automatically; only template or asset changes still need `s3te sync --env <name>`.
 
+Manual versus automatic responsibilities in this step:
+
+- Manual: enable DynamoDB Streams on the Webiny source table
+- Automatic during `s3te deploy`: read `LatestStreamArn`, create the Lambda event source mapping, and wire the S3TE Webiny mirror Lambda into the environment stack
+
 </details>
 
 <details>
@@ -637,15 +1089,4 @@ For localized Webiny projects, the language block can also carry the mapping exp
 
 </details>
 
-<details>
-  <summary>Content template commands</summary>
-
-These commands are useful both with Webiny and with local JSON content files:
-
-- `dbpart`
-- `dbmulti`
-- `dbmultifile`
-- `dbitem`
-- `dbmultifileitem`
-
-</details>
+The content-driven tags are documented in [Template Commands](#template-commands), section [Webiny Features](#webiny-features).

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@projectdochelp/s3te",
-  "version": "3.2.1",
+  "version": "3.2.3",
   "description": "CLI, render core, AWS adapter, and testkit for S3TemplateEngine projects",
   "repository": {
     "type": "git",
@@ -51,7 +51,8 @@
     "@aws-sdk/client-sfn": "^3.0.0",
     "@aws-sdk/client-ssm": "^3.0.0",
     "@aws-sdk/lib-dynamodb": "^3.0.0",
-    "@aws-sdk/util-dynamodb": "^3.0.0"
+    "@aws-sdk/util-dynamodb": "^3.0.0",
+    "fast-xml-parser": "^4.0.8"
   },
   "publishConfig": {
     "access": "public"

package/packages/aws-adapter/src/deploy.mjs

@@ -344,6 +344,7 @@ function buildEnvironmentStackParameters({
     `InvalidationSchedulerArtifactKey=${uploadedArtifacts.invalidationScheduler}`,
     `InvalidationExecutorArtifactKey=${uploadedArtifacts.invalidationExecutor}`,
     `ContentMirrorArtifactKey=${uploadedArtifacts.contentMirror}`,
+    `SitemapUpdaterArtifactKey=${uploadedArtifacts.sitemapUpdater}`,
     `RuntimeManifestValue=${runtimeManifestValue}`,
     `WebinySourceTableStreamArn=${webinyStreamArn}`
   ];
@@ -370,6 +371,9 @@ export async function deployAwsProject({
   if (requestedFeatureSet.has("webiny") && !runtimeConfig.integrations.webiny.enabled) {
     throw new S3teError("ADAPTER_ERROR", "Feature webiny was requested but is not enabled in s3te.config.json.");
   }
+  if (requestedFeatureSet.has("sitemap") && !runtimeConfig.integrations.sitemap.enabled) {
+    throw new S3teError("ADAPTER_ERROR", "Feature sitemap was requested but is not enabled in s3te.config.json.");
+  }
 
   await ensureAwsCliAvailable({ cwd: projectDir });
   await ensureAwsCredentials({

package/packages/aws-adapter/src/features.mjs

@@ -1,4 +1,7 @@
-import { resolveEnvironmentWebinyIntegration } from "../../core/src/index.mjs";
+import {
+  resolveEnvironmentSitemapIntegration,
+  resolveEnvironmentWebinyIntegration
+} from "../../core/src/index.mjs";
 
 export function getConfiguredFeatures(config, environment) {
   const features = [];
@@ -7,16 +10,25 @@ export function getConfiguredFeatures(config, environment) {
     if (resolveEnvironmentWebinyIntegration(config, environment).enabled) {
       features.push("webiny");
     }
+    if (resolveEnvironmentSitemapIntegration(config, environment).enabled) {
+      features.push("sitemap");
+    }
     return features;
   }
 
   const hasAnyEnvironmentWebiny = Object.keys(config.environments ?? {}).some((environmentName) => (
     resolveEnvironmentWebinyIntegration(config, environmentName).enabled
   ));
+  const hasAnyEnvironmentSitemap = Object.keys(config.environments ?? {}).some((environmentName) => (
+    resolveEnvironmentSitemapIntegration(config, environmentName).enabled
+  ));
 
   if (hasAnyEnvironmentWebiny) {
     features.push("webiny");
   }
+  if (hasAnyEnvironmentSitemap) {
+    features.push("sitemap");
+  }
 
   return features;
 }

package/packages/aws-adapter/src/manifest.mjs

@@ -30,7 +30,8 @@ function buildFunctionNames(runtimeConfig) {
     renderWorker: `${runtimeConfig.stackPrefix}_s3te_render_worker`,
     invalidationScheduler: `${runtimeConfig.stackPrefix}_s3te_invalidation_scheduler`,
     invalidationExecutor: `${runtimeConfig.stackPrefix}_s3te_invalidation_executor`,
-    contentMirror: runtimeConfig.integrations.webiny.enabled ? `${runtimeConfig.stackPrefix}_s3te_content_mirror` : ""
+    contentMirror: runtimeConfig.integrations.webiny.enabled ? `${runtimeConfig.stackPrefix}_s3te_content_mirror` : "",
+    sitemapUpdater: runtimeConfig.integrations.sitemap.enabled ? `${runtimeConfig.stackPrefix}_s3te_sitemap_updater` : ""
   };
 }
 
@@ -79,6 +80,9 @@ export function buildAwsRuntimeManifest({ config, environment, stackOutputs = {}
             mirrorTableName: runtimeConfig.integrations.webiny.mirrorTableName,
             relevantModels: [...runtimeConfig.integrations.webiny.relevantModels],
             tenant: runtimeConfig.integrations.webiny.tenant
+          },
+          sitemap: {
+            enabled: runtimeConfig.integrations.sitemap.enabled
           }
         },
         variants: runtimeConfig.variants

package/packages/aws-adapter/src/package.mjs

@@ -25,7 +25,8 @@ const RUNTIME_PACKAGE_DEPENDENCIES = [
   "@aws-sdk/client-sfn",
   "@aws-sdk/client-ssm",
   "@aws-sdk/lib-dynamodb",
-  "@aws-sdk/util-dynamodb"
+  "@aws-sdk/util-dynamodb",
+  "fast-xml-parser"
 ];
 const INTERNAL_RUNTIME_DIRECTORIES = [
   {
@@ -226,6 +227,9 @@ export async function packageAwsProject({
   if (features.includes("webiny") && !runtimeConfig.integrations.webiny.enabled) {
     throw new S3teError("ADAPTER_ERROR", "Feature webiny was requested but is not enabled in s3te.config.json.");
   }
+  if (features.includes("sitemap") && !runtimeConfig.integrations.sitemap.enabled) {
+    throw new S3teError("ADAPTER_ERROR", "Feature sitemap was requested but is not enabled in s3te.config.json.");
+  }
 
   const resolvedFeatures = resolveRequestedFeatures(config, features, environment);
   const packageDir = outDir
@@ -267,6 +271,11 @@ export async function packageAwsProject({
       archive: path.join(lambdaDir, "content-mirror.zip"),
       parameter: "ContentMirrorArtifactKey",
       s3Key: `lambda/content-mirror.zip`
+    },
+    sitemapUpdater: {
+      archive: path.join(lambdaDir, "sitemap-updater.zip"),
+      parameter: "SitemapUpdaterArtifactKey",
+      s3Key: "lambda/sitemap-updater.zip"
     }
   };
 

package/packages/aws-adapter/src/runtime/common.mjs

@@ -258,6 +258,9 @@ export function buildCoreConfigFromEnvironment(manifest, environmentName) {
         mirrorTableName: environment.integrations.webiny.mirrorTableName,
         relevantModels: [...environment.integrations.webiny.relevantModels],
         tenant: environment.integrations.webiny.tenant
+      },
+      sitemap: {
+        enabled: environment.integrations.sitemap?.enabled ?? false
       }
     }
   };

package/packages/aws-adapter/src/runtime/sitemap-updater.mjs

@@ -0,0 +1,221 @@
+import { XMLBuilder, XMLParser } from "fast-xml-parser";
+
+import {
+  createAwsClients,
+  decodeS3Key,
+  loadEnvironmentManifest
+} from "./common.mjs";
+
+const SITEMAP_XML_NAMESPACE = "http://www.sitemaps.org/schemas/sitemap/0.9";
+const parser = new XMLParser({
+  ignoreAttributes: false,
+  isArray: (name) => name === "url"
+});
+const builder = new XMLBuilder({
+  ignoreAttributes: false,
+  format: true
+});
+
+function createEmptySitemapDocument() {
+  return {
+    "?xml": {
+      "@_version": "1.0",
+      "@_encoding": "UTF-8"
+    },
+    urlset: {
+      "@_xmlns": SITEMAP_XML_NAMESPACE,
+      url: []
+    }
+  };
+}
+
+async function bodyToUtf8(body) {
+  if (typeof body?.transformToString === "function") {
+    return body.transformToString("utf8");
+  }
+
+  if (Buffer.isBuffer(body)) {
+    return body.toString("utf8");
+  }
+
+  if (body instanceof Uint8Array) {
+    return Buffer.from(body).toString("utf8");
+  }
+
+  return String(body ?? "");
+}
+
+export function normalizeSitemapDocument(document) {
+  const candidate = document?.urlset ? document : createEmptySitemapDocument();
+  const urls = candidate?.urlset?.url;
+
+  return {
+    "?xml": {
+      "@_version": candidate?.["?xml"]?.["@_version"] ?? "1.0",
+      "@_encoding": candidate?.["?xml"]?.["@_encoding"] ?? "UTF-8"
+    },
+    urlset: {
+      "@_xmlns": candidate?.urlset?.["@_xmlns"] ?? SITEMAP_XML_NAMESPACE,
+      url: Array.isArray(urls)
+        ? urls.filter((entry) => entry?.loc)
+        : (urls?.loc ? [urls] : [])
+    }
+  };
+}
+
+async function loadCurrentSitemap(s3, bucketName) {
+  try {
+    const response = await s3.getObject({
+      Bucket: bucketName,
+      Key: "sitemap.xml"
+    }).promise();
+    return normalizeSitemapDocument(parser.parse(await bodyToUtf8(response.Body)));
+  } catch (error) {
+    const errorCode = error?.name ?? error?.Code ?? error?.code;
+    if (errorCode === "NoSuchKey" || errorCode === "NoSuchBucket" || errorCode === "NotFound") {
+      return createEmptySitemapDocument();
+    }
+    throw error;
+  }
+}
+
+export function findLanguageTargetByBucket(environmentManifest, bucketName) {
+  for (const [variantName, variantConfig] of Object.entries(environmentManifest.variants ?? {})) {
+    for (const [languageCode, languageConfig] of Object.entries(variantConfig.languages ?? {})) {
+      if (languageConfig.targetBucket === bucketName) {
+        return {
+          variantName,
+          variantConfig,
+          languageCode,
+          languageConfig
+        };
+      }
+    }
+  }
+
+  return null;
+}
+
+function encodePathSegments(key) {
+  return String(key)
+    .split("/")
+    .filter((segment) => segment.length > 0)
+    .map((segment) => encodeURIComponent(segment))
+    .join("/");
+}
+
+export function buildSitemapUrl({ baseUrl, key, indexDocument, notFoundDocument }) {
+  const normalizedKey = String(key ?? "").replace(/^\/+/, "");
+  if (!normalizedKey || normalizedKey === "sitemap.xml" || normalizedKey === notFoundDocument) {
+    return null;
+  }
+
+  const normalizedBaseUrl = String(baseUrl ?? "").replace(/^https?:\/\//i, "").replace(/\/+$/, "");
+  if (!normalizedBaseUrl) {
+    return null;
+  }
+
+  if (normalizedKey === indexDocument) {
+    return `https://${normalizedBaseUrl}/`;
+  }
+
+  if (normalizedKey.endsWith(`/${indexDocument}`)) {
+    const directoryKey = normalizedKey.slice(0, -(indexDocument.length + 1));
+    const encodedDirectory = encodePathSegments(directoryKey);
+    return `https://${normalizedBaseUrl}/${encodedDirectory}/`;
+  }
+
+  return `https://${normalizedBaseUrl}/${encodePathSegments(normalizedKey)}`;
+}
+
+export function applySitemapRecords(sitemapDocument, sitemapRecords = []) {
+  const normalizedDocument = normalizeSitemapDocument(sitemapDocument);
+  const entries = new Map((normalizedDocument.urlset.url ?? []).map((entry) => [entry.loc, {
+    loc: entry.loc,
+    lastmod: entry.lastmod
+  }]));
+
+  for (const record of sitemapRecords) {
+    if (!record?.loc) {
+      continue;
+    }
+
+    const lastmod = String(record.lastmod ?? new Date().toISOString()).slice(0, 10);
+    if (record.action === "delete") {
+      entries.delete(record.loc);
+      continue;
+    }
+
+    entries.set(record.loc, {
+      loc: record.loc,
+      lastmod
+    });
+  }
+
+  normalizedDocument.urlset.url = [...entries.values()].sort((left, right) => left.loc.localeCompare(right.loc));
+  return normalizedDocument;
+}
+
+export async function handler(event) {
+  const environmentName = process.env.S3TE_ENVIRONMENT;
+  const runtimeParameter = process.env.S3TE_RUNTIME_PARAMETER;
+
+  const clients = createAwsClients();
+  const { environment: environmentManifest } = await loadEnvironmentManifest(
+    clients.ssm,
+    runtimeParameter,
+    environmentName
+  );
+
+  const updatesByBucket = new Map();
+
+  for (const record of event.Records ?? []) {
+    const bucketName = record.s3?.bucket?.name;
+    const key = decodeS3Key(record.s3?.object?.key ?? "");
+    const target = findLanguageTargetByBucket(environmentManifest, bucketName);
+    if (!bucketName || !key || !target) {
+      continue;
+    }
+
+    const loc = buildSitemapUrl({
+      baseUrl: target.languageConfig.baseUrl,
+      key,
+      indexDocument: target.variantConfig.routing.indexDocument,
+      notFoundDocument: target.variantConfig.routing.notFoundDocument
+    });
+    if (!loc) {
+      continue;
+    }
+
+    if (!updatesByBucket.has(bucketName)) {
+      updatesByBucket.set(bucketName, []);
+    }
+    updatesByBucket.get(bucketName).push({
+      action: String(record.eventName).startsWith("ObjectRemoved:") ? "delete" : "upsert",
+      loc,
+      lastmod: record.eventTime
+    });
+  }
+
+  let updatedBuckets = 0;
+
+  for (const [bucketName, updates] of updatesByBucket.entries()) {
+    const sitemapDocument = applySitemapRecords(
+      await loadCurrentSitemap(clients.s3, bucketName),
+      updates
+    );
+
+    await clients.s3.putObject({
+      Bucket: bucketName,
+      Key: "sitemap.xml",
+      Body: builder.build(sitemapDocument),
+      ContentType: "application/xml; charset=utf-8"
+    }).promise();
+
+    updatedBuckets += 1;
+  }
+
+  return {
+    updatedBuckets
+  };
+}

package/packages/aws-adapter/src/template.mjs

@@ -35,6 +35,26 @@ function lambdaCode(keyParameter) {
   };
 }
 
+function buildSitemapNotificationConfigurations(functionLogicalId) {
+  const suffixes = [".html", ".htm"];
+  const events = ["s3:ObjectCreated:*", "s3:ObjectRemoved:*"];
+
+  return events.flatMap((eventName) => suffixes.map((suffix) => ({
+    Event: eventName,
+    Function: { "Fn::GetAtt": [functionLogicalId, "Arn"] },
+    Filter: {
+      S3Key: {
+        Rules: [
+          {
+            Name: "suffix",
+            Value: suffix
+          }
+        ]
+      }
+    }
+  })));
+}
+
 function lambdaRuntimeProperties(runtimeConfig, roleRef, name, keyParameter, handlerName, extra = {}) {
   return {
     Type: "AWS::Lambda::Function",
@@ -117,7 +137,8 @@ export function buildCloudFormationTemplate({ config, environment, features = []
     renderWorker: `${runtimeConfig.stackPrefix}_s3te_render_worker`,
     invalidationScheduler: `${runtimeConfig.stackPrefix}_s3te_invalidation_scheduler`,
     invalidationExecutor: `${runtimeConfig.stackPrefix}_s3te_invalidation_executor`,
-    contentMirror: `${runtimeConfig.stackPrefix}_s3te_content_mirror`
+    contentMirror: `${runtimeConfig.stackPrefix}_s3te_content_mirror`,
+    sitemapUpdater: `${runtimeConfig.stackPrefix}_s3te_sitemap_updater`
   };
 
   const parameters = {
@@ -140,6 +161,10 @@ export function buildCloudFormationTemplate({ config, environment, features = []
       Type: "String",
       Default: ""
     },
+    SitemapUpdaterArtifactKey: {
+      Type: "String",
+      Default: ""
+    },
     RuntimeManifestValue: {
       Type: "String",
       Default: "{}"
@@ -369,6 +394,26 @@ export function buildCloudFormationTemplate({ config, environment, features = []
     };
   }
 
+  if (featureSet.has("sitemap") && runtimeConfig.integrations.sitemap.enabled) {
+    resources.SitemapUpdater = lambdaRuntimeProperties(
+      runtimeConfig,
+      "ExecutionRole",
+      functionNames.sitemapUpdater,
+      "SitemapUpdaterArtifactKey",
+      "sitemap-updater",
+      {
+        Timeout: 300,
+        MemorySize: 512,
+        Environment: {
+          Variables: {
+            S3TE_ENVIRONMENT: environment,
+            S3TE_RUNTIME_PARAMETER: runtimeConfig.runtimeParameterName
+          }
+        }
+      }
+    );
+  }
+
   outputs.StackName = { Value: runtimeConfig.stackName };
   outputs.RuntimeManifestParameterName = {
     Value: runtimeConfig.runtimeParameterName
@@ -384,6 +429,9 @@ export function buildCloudFormationTemplate({ config, environment, features = []
   if (resources.ContentMirror) {
     outputs.ContentMirrorFunctionName = { Value: functionNames.contentMirror };
   }
+  if (resources.SitemapUpdater) {
+    outputs.SitemapUpdaterFunctionName = { Value: functionNames.sitemapUpdater };
+  }
 
   for (const [variantName, variantConfig] of Object.entries(runtimeConfig.variants)) {
     const codeBucketLogicalId = cfName(sanitizeLogicalId(variantName), "CodeBucket");
@@ -417,12 +465,20 @@ export function buildCloudFormationTemplate({ config, environment, features = []
 
       resources[outputBucketLogicalId] = {
         Type: "AWS::S3::Bucket",
+        ...(resources.SitemapUpdater ? { DependsOn: ["SitemapUpdaterPermission"] } : {}),
         Properties: {
           BucketName: languageConfig.targetBucket,
           WebsiteConfiguration: {
             IndexDocument: variantConfig.routing.indexDocument,
             ErrorDocument: variantConfig.routing.notFoundDocument
           },
+          ...(resources.SitemapUpdater
+            ? {
+                NotificationConfiguration: {
+                  LambdaConfigurations: buildSitemapNotificationConfigurations("SitemapUpdater")
+                }
+              }
+            : {}),
           PublicAccessBlockConfiguration: {
             BlockPublicAcls: false,
             BlockPublicPolicy: false,
@@ -544,6 +600,17 @@ export function buildCloudFormationTemplate({ config, environment, features = []
     }
   };
 
+  if (resources.SitemapUpdater) {
+    resources.SitemapUpdaterPermission = {
+      Type: "AWS::Lambda::Permission",
+      Properties: {
+        Action: "lambda:InvokeFunction",
+        FunctionName: { Ref: "SitemapUpdater" },
+        Principal: "s3.amazonaws.com"
+      }
+    };
+  }
+
   return {
     AWSTemplateFormatVersion: "2010-09-09",
     Description: `S3TE environment stack for ${config.project.name} (${environment})`,

package/packages/cli/bin/s3te.mjs

@@ -385,6 +385,8 @@ async function main() {
       environment: asArray(options.env)[0],
       enableWebiny: Boolean(options["enable-webiny"]),
       disableWebiny: Boolean(options["disable-webiny"]),
+      enableSitemap: Boolean(options["enable-sitemap"]),
+      disableSitemap: Boolean(options["disable-sitemap"]),
       webinySourceTable: options["webiny-source-table"],
       webinyTenant: options["webiny-tenant"],
       webinyModels: asArray(options["webiny-model"])

package/packages/cli/src/project.mjs

@@ -335,6 +335,23 @@ function schemaTemplate() {
                 }
               }
             }
+          },
+          sitemap: {
+            type: "object",
+            additionalProperties: false,
+            properties: {
+              enabled: { type: "boolean" },
+              environments: {
+                type: "object",
+                additionalProperties: {
+                  type: "object",
+                  additionalProperties: false,
+                  properties: {
+                    enabled: { type: "boolean" }
+                  }
+                }
+              }
+            }
           }
         }
       }
@@ -986,6 +1003,8 @@ export async function migrateProject(configPath, rawConfig, writeChanges) {
 
   const enableWebiny = Boolean(options.enableWebiny);
   const disableWebiny = Boolean(options.disableWebiny);
+  const enableSitemap = Boolean(options.enableSitemap);
+  const disableSitemap = Boolean(options.disableSitemap);
   const targetEnvironment = options.environment ? String(options.environment).trim() : "";
   const webinySourceTable = options.webinySourceTable ? String(options.webinySourceTable).trim() : "";
   const webinyTenant = options.webinyTenant ? String(options.webinyTenant).trim() : "";
@@ -994,6 +1013,9 @@ export async function migrateProject(configPath, rawConfig, writeChanges) {
   if (enableWebiny && disableWebiny) {
     throw new S3teError("CONFIG_CONFLICT_ERROR", "migrate does not allow --enable-webiny and --disable-webiny at the same time.");
   }
+  if (enableSitemap && disableSitemap) {
+    throw new S3teError("CONFIG_CONFLICT_ERROR", "migrate does not allow --enable-sitemap and --disable-sitemap at the same time.");
+  }
 
   const touchesWebiny = enableWebiny || disableWebiny || Boolean(webinySourceTable) || Boolean(webinyTenant) || webinyModels.length > 0;
   if (touchesWebiny) {
@@ -1076,6 +1098,48 @@ export async function migrateProject(configPath, rawConfig, writeChanges) {
     }
   }
 
+  const touchesSitemap = enableSitemap || disableSitemap;
+  if (touchesSitemap) {
+    if (targetEnvironment && !nextConfig.environments?.[targetEnvironment]) {
+      throw new S3teError("CONFIG_CONFLICT_ERROR", `Unknown environment for migrate: ${targetEnvironment}.`);
+    }
+
+    const existingIntegrations = nextConfig.integrations ?? {};
+    const existingSitemap = existingIntegrations.sitemap ?? {};
+    const existingEnvironmentOverrides = existingSitemap.environments ?? {};
+    const existingTargetSitemap = targetEnvironment
+      ? (existingEnvironmentOverrides[targetEnvironment] ?? {})
+      : existingSitemap;
+    const nextEnabled = disableSitemap
+      ? false
+      : (enableSitemap || Boolean(targetEnvironment
+          ? (existingTargetSitemap.enabled ?? existingSitemap.enabled)
+          : existingSitemap.enabled));
+
+    nextConfig.integrations = {
+      ...existingIntegrations,
+      sitemap: targetEnvironment
+        ? {
+            ...existingSitemap,
+            environments: {
+              ...existingEnvironmentOverrides,
+              [targetEnvironment]: {
+                ...existingTargetSitemap,
+                enabled: nextEnabled
+              }
+            }
+          }
+        : {
+            ...existingSitemap,
+            enabled: nextEnabled,
+            environments: existingEnvironmentOverrides
+          }
+    };
+
+    const scopeLabel = targetEnvironment ? ` for environment ${targetEnvironment}` : "";
+    changes.push(nextEnabled ? `Enabled sitemap integration${scopeLabel}.` : `Disabled sitemap integration${scopeLabel}.`);
+  }
+
   if (options.writeChanges) {
     await writeTextFile(configPath, JSON.stringify(nextConfig, null, 2) + "\n");
   }

package/packages/core/src/config.mjs

@@ -75,12 +75,27 @@ function environmentHostPrefix(config, environmentName) {
 }
 
 function prefixHostForEnvironment(config, host, environmentName) {
-  const prefix = environmentHostPrefix(config, environmentName);
-  if (!prefix) {
+  if (!hasProductionEnvironment(config) || isProductionEnvironment(environmentName)) {
     return host;
   }
 
-  return host.startsWith(prefix) ? host : `${prefix}${host}`;
+  const normalizedHost = String(host).trim();
+  if (!normalizedHost) {
+    return normalizedHost;
+  }
+
+  if (normalizedHost.startsWith(`${environmentName}.`) || normalizedHost.startsWith(`${environmentName}-`)) {
+    return normalizedHost;
+  }
+
+  const labels = normalizedHost.split(".");
+  if (labels.length <= 2) {
+    const prefix = environmentHostPrefix(config, environmentName);
+    return `${prefix}${normalizedHost}`;
+  }
+
+  const [firstLabel, ...remainingLabels] = labels;
+  return `${environmentName}-${firstLabel}.${remainingLabels.join(".")}`;
 }
 
 function isValidConfiguredHost(value) {
@@ -143,6 +158,12 @@ function resolveWebinyConfigDefaults(webinyConfig = {}) {
   };
 }
 
+function resolveSitemapConfigDefaults(sitemapConfig = {}) {
+  return {
+    enabled: sitemapConfig.enabled ?? false
+  };
+}
+
 function resolveProjectWebinyConfig(projectConfig) {
   const baseConfig = resolveWebinyConfigDefaults(projectConfig.integrations?.webiny ?? {});
   const environmentConfigs = Object.fromEntries(Object.entries(projectConfig.integrations?.webiny?.environments ?? {}).map(([environmentName, webinyConfig]) => ([
@@ -162,6 +183,21 @@ function resolveProjectWebinyConfig(projectConfig) {
   };
 }
 
+function resolveProjectSitemapConfig(projectConfig) {
+  const baseConfig = resolveSitemapConfigDefaults(projectConfig.integrations?.sitemap ?? {});
+  const environmentConfigs = Object.fromEntries(Object.entries(projectConfig.integrations?.sitemap?.environments ?? {}).map(([environmentName, sitemapConfig]) => ([
+    environmentName,
+    {
+      enabled: sitemapConfig.enabled
+    }
+  ])));
+
+  return {
+    ...baseConfig,
+    environments: environmentConfigs
+  };
+}
+
 export async function loadProjectConfig(configPath) {
   const raw = await fs.readFile(configPath, "utf8");
   try {
@@ -247,7 +283,8 @@ export function resolveProjectConfig(projectConfig) {
   };
 
   const integrations = {
-    webiny: resolveProjectWebinyConfig(projectConfig)
+    webiny: resolveProjectWebinyConfig(projectConfig),
+    sitemap: resolveProjectSitemapConfig(projectConfig)
   };
 
   for (const [variantName, variantConfig] of Object.entries(variants)) {
@@ -317,6 +354,15 @@ export function resolveEnvironmentWebinyIntegration(config, environmentName) {
   };
 }
 
+export function resolveEnvironmentSitemapIntegration(config, environmentName) {
+  const baseConfig = resolveSitemapConfigDefaults(config.integrations?.sitemap ?? {});
+  const environmentOverride = config.integrations?.sitemap?.environments?.[environmentName] ?? {};
+
+  return {
+    enabled: environmentOverride.enabled ?? baseConfig.enabled
+  };
+}
+
 export function resolveTableNames(config, environmentName) {
   const context = createPlaceholderContext(config, environmentName);
   const webinyConfig = resolveEnvironmentWebinyIntegration(config, environmentName);
@@ -340,6 +386,7 @@ export function resolveStackName(config, environmentName) {
 export function buildEnvironmentRuntimeConfig(config, environmentName, stackOutputs = {}) {
   const environmentConfig = config.environments[environmentName];
   const webinyConfig = resolveEnvironmentWebinyIntegration(config, environmentName);
+  const sitemapConfig = resolveEnvironmentSitemapIntegration(config, environmentName);
   const tables = resolveTableNames(config, environmentName);
   const runtimeParameterName = resolveRuntimeManifestParameterName(config, environmentName);
   const stackName = resolveStackName(config, environmentName);
@@ -388,6 +435,9 @@ export function buildEnvironmentRuntimeConfig(config, environmentName, stackOutp
       webiny: {
         ...webinyConfig,
         mirrorTableName: tables.webinyMirror
+      },
+      sitemap: {
+        ...sitemapConfig
       }
     },
     variants
@@ -502,6 +552,7 @@ export async function validateAndResolveProjectConfig(projectConfig, options = {
   }
 
   const configuredWebiny = projectConfig.integrations?.webiny;
+  const configuredSitemap = projectConfig.integrations?.sitemap;
   for (const [environmentName] of environmentEntries) {
     const environmentWebinyConfig = resolveEnvironmentWebinyIntegration(resolveProjectConfig({
       ...projectConfig,
@@ -524,6 +575,15 @@ export async function validateAndResolveProjectConfig(projectConfig, options = {
     }
   }
 
+  for (const environmentName of Object.keys(configuredSitemap?.environments ?? {})) {
+    if (!projectConfig.environments?.[environmentName]) {
+      errors.push({
+        code: "CONFIG_CONFLICT_ERROR",
+        message: `integrations.sitemap.environments.${environmentName} does not match a configured environment.`
+      });
+    }
+  }
+
   for (const [variantName, pattern] of Object.entries(projectConfig.aws?.codeBuckets ?? {})) {
     ensureKnownPlaceholders(pattern, `aws.codeBuckets.${variantName}`, errors);
   }

package/packages/core/src/index.mjs

@@ -7,6 +7,7 @@ export {
   resolveBaseUrl,
   resolveCodeBucketName,
   resolveCloudFrontAliases,
+  resolveEnvironmentSitemapIntegration,
   resolveEnvironmentWebinyIntegration,
   resolveRuntimeManifestParameterName,
   resolveProjectConfig,