@anthusai/papyrus 1.0.0-next.2 → 1.0.0-next.21

package/infra/build-specs.ts

@@ -0,0 +1,141 @@
+import { AmplifyAppShellSiteConfig, resolveStoragePreviewPrefix } from "./site-config";
+
+export type BuildSpecAppName = "cms-production" | "cms-staging" | "reader";
+
+export function papyrusVersionToPep440(version: string): string {
+  const match = /^(\d+\.\d+\.\d+)(?:-[0-9A-Za-z-]+\.(\d+))?$/.exec(version);
+  if (!match) throw new Error(`cannot map ${version} to PEP 440`);
+  return match[2] === undefined ? match[1] : `${match[1]}.dev${match[2]}`;
+}
+
+function yamlScalar(command: string): string {
+  const needsQuoting = /: | #|^[-?:,\[\]{}#&*!|>'"%@`]|:$/.test(command);
+  return needsQuoting ? `'${command.replace(/'/g, "''")}'` : command;
+}
+
+function commandLines(commands: string[], indent: string): string[] {
+  return commands.map((command) => `${indent}- ${yamlScalar(command)}`);
+}
+
+const NPM_CLEAN_INSTALL = "npm ci --cache .npm --prefer-offline";
+
+const FRONTEND_ENVIRONMENT_CAPTURE =
+  "env | grep -e '^PAPYRUS_' -e '^SITE_ENV=' -e '^NEXT_PUBLIC_' >> .env.production";
+
+const CHECKOUT_AS_PAPYRUS_ROOT = "PAPYRUS_ROOT=\"$PWD\"";
+
+const STAGING_RUNTIME_OUTPUTS_COMMANDS = [
+  "cp amplify_outputs.json .next/amplify_outputs.json",
+  "echo PAPYRUS_AMPLIFY_OUTPUTS=.next/amplify_outputs.json >> .env.production",
+];
+
+function pythonProvisioningCommands(config: AmplifyAppShellSiteConfig): string[] {
+  return [
+    "export UV_CACHE_DIR=\"$PWD/.uv-cache\"",
+    "curl -LsSf https://astral.sh/uv/install.sh | sh",
+    "export PATH=\"$HOME/.local/bin:$PATH\"",
+    "uv python install 3.12",
+    "uv venv --python 3.12 .venv",
+    `uv pip install --python .venv "papyrus-newsroom[markus]==${papyrusVersionToPep440(config.papyrusVersion)}"`,
+    "export PATH=\"$PWD/.venv/bin:$PATH\"",
+  ];
+}
+
+function reader(config: AmplifyAppShellSiteConfig): NonNullable<AmplifyAppShellSiteConfig["reader"]> {
+  if (!config.reader) throw new Error(`site ${config.siteId} has no reader app (frontend ${config.frontend})`);
+  return config.reader;
+}
+
+function frontendSection(preBuildCommands: string[], buildCommands: string[], artifactsDirectory: string, cachePaths: string[]): string[] {
+  const lines = ["frontend:", "  phases:"];
+  if (preBuildCommands.length > 0) {
+    lines.push("    preBuild:", "      commands:", ...commandLines(preBuildCommands, "        "));
+  }
+  lines.push(
+    "    build:",
+    "      commands:",
+    ...commandLines(buildCommands, "        "),
+    "  artifacts:",
+    `    baseDirectory: ${artifactsDirectory}`,
+    "    files:",
+    "      - '**/*'",
+    "  cache:",
+    "    paths:",
+    ...cachePaths.map((cachePath) => `      - ${cachePath}`),
+  );
+  return lines;
+}
+
+export function cmsProductionBuildSpec(config: AmplifyAppShellSiteConfig): string {
+  return [
+    "version: 1",
+    "backend:",
+    "  phases:",
+    "    build:",
+    "      commands:",
+    ...commandLines(
+      [
+        NPM_CLEAN_INSTALL,
+        "if [ -z \"${PAPYRUS_CONSOLE_RESPONDER_IMAGE_URI:-}\" ]; then export PAPYRUS_CONSOLE_RESPONDER_ALLOW_LOCAL_BUILD=true; fi",
+        "npx ampx pipeline-deploy --branch $AWS_BRANCH --app-id $AWS_APP_ID",
+      ],
+      "        ",
+    ),
+    ...frontendSection(
+      [],
+      [FRONTEND_ENVIRONMENT_CAPTURE, "npx papyrus-app sync && npm run build"],
+      ".next",
+      [".next/cache/**/*", ".npm/**/*"],
+    ),
+  ].join("\n") + "\n";
+}
+
+export function cmsStagingBuildSpec(config: AmplifyAppShellSiteConfig): string {
+  const preBuild = [NPM_CLEAN_INSTALL, "npx ampx generate outputs --branch main --app-id $AWS_APP_ID"];
+  const cachePaths = [".next/cache/**/*", ".npm/**/*"];
+  if (config.frontend === "markus-static") {
+    const readerConfig = reader(config);
+    preBuild.push(
+      ...pythonProvisioningCommands(config),
+      `${CHECKOUT_AS_PAPYRUS_ROOT} papyrus ops content export-published --drafts --out content-export --clean`,
+      readerConfig.buildCommand,
+      `${CHECKOUT_AS_PAPYRUS_ROOT} papyrus ops content upload-preview --dir ${readerConfig.baseDirectory} --prefix ${resolveStoragePreviewPrefix(config)}`,
+    );
+    cachePaths.push(".uv-cache/**/*");
+  }
+  return [
+    "version: 1",
+    ...frontendSection(
+      preBuild,
+      [
+        FRONTEND_ENVIRONMENT_CAPTURE,
+        "npx papyrus-app sync && npm run build",
+        ...STAGING_RUNTIME_OUTPUTS_COMMANDS,
+      ],
+      ".next",
+      cachePaths,
+    ),
+  ].join("\n") + "\n";
+}
+
+export function readerBuildSpec(config: AmplifyAppShellSiteConfig): string {
+  const readerConfig = reader(config);
+  return [
+    "version: 1",
+    ...frontendSection(
+      [
+        ...pythonProvisioningCommands(config),
+        "papyrus ops content export-published --auth guest --out content-export --clean",
+      ],
+      [readerConfig.buildCommand],
+      readerConfig.baseDirectory,
+      [".uv-cache/**/*"],
+    ),
+  ].join("\n") + "\n";
+}
+
+export function buildSpecFor(config: AmplifyAppShellSiteConfig, app: BuildSpecAppName): string {
+  if (app === "cms-production") return cmsProductionBuildSpec(config);
+  if (app === "cms-staging") return cmsStagingBuildSpec(config);
+  return readerBuildSpec(config);
+}

package/infra/github-oidc-provider.js

@@ -0,0 +1,24 @@
+import { CfnOutput, Stack } from "aws-cdk-lib";
+import * as iam from "aws-cdk-lib/aws-iam";
+export const GITHUB_OIDC_PROVIDER_HOST = "token.actions.githubusercontent.com";
+/**
+ * Account-global singleton: AWS allows one IAM OIDC provider per issuer URL per
+ * account, so this never belongs in a per-site stack. Deploy it once per
+ * account, and only after `aws iam list-open-id-connect-providers` shows no
+ * provider for token.actions.githubusercontent.com. When one already exists,
+ * do not deploy this stack: per-site CI roles only reference the provider by
+ * its ARN (arn:aws:iam::<account>:oidc-provider/token.actions.githubusercontent.com)
+ * and work against an existing provider unchanged.
+ */
+export class GithubOidcProviderStack extends Stack {
+    providerArn;
+    constructor(scope, id, props) {
+        super(scope, id, props);
+        const provider = new iam.OpenIdConnectProvider(this, "GithubOidc", {
+            url: `https://${GITHUB_OIDC_PROVIDER_HOST}`,
+            clientIds: ["sts.amazonaws.com"],
+        });
+        this.providerArn = provider.openIdConnectProviderArn;
+        new CfnOutput(this, "GithubOidcProviderArn", { value: provider.openIdConnectProviderArn });
+    }
+}

package/infra/github-oidc-provider.ts

@@ -0,0 +1,30 @@
+import { Construct } from "constructs";
+import { CfnOutput, Stack, StackProps } from "aws-cdk-lib";
+import * as iam from "aws-cdk-lib/aws-iam";
+
+export const GITHUB_OIDC_PROVIDER_HOST = "token.actions.githubusercontent.com";
+
+/**
+ * Account-global singleton: AWS allows one IAM OIDC provider per issuer URL per
+ * account, so this never belongs in a per-site stack. Deploy it once per
+ * account, and only after `aws iam list-open-id-connect-providers` shows no
+ * provider for token.actions.githubusercontent.com. When one already exists,
+ * do not deploy this stack: per-site CI roles only reference the provider by
+ * its ARN (arn:aws:iam::<account>:oidc-provider/token.actions.githubusercontent.com)
+ * and work against an existing provider unchanged.
+ */
+export class GithubOidcProviderStack extends Stack {
+  public readonly providerArn: string;
+
+  constructor(scope: Construct, id: string, props?: StackProps) {
+    super(scope, id, props);
+
+    const provider = new iam.OpenIdConnectProvider(this, "GithubOidc", {
+      url: `https://${GITHUB_OIDC_PROVIDER_HOST}`,
+      clientIds: ["sts.amazonaws.com"],
+    });
+
+    this.providerArn = provider.openIdConnectProviderArn;
+    new CfnOutput(this, "GithubOidcProviderArn", { value: provider.openIdConnectProviderArn });
+  }
+}

package/infra/index.js

@@ -10,3 +10,6 @@ try {
   );
 }
 export const { AmplifyAppShellStack } = await import("./amplify-app-shell.js");
+export const { GithubOidcProviderStack } = await import("./github-oidc-provider.js");
+export { parseSiteConfig } from "./site-config.js";
+export { cmsProductionBuildSpec, cmsStagingBuildSpec, readerBuildSpec, buildSpecFor } from "./build-specs.js";

package/infra/site-config.js

@@ -0,0 +1,273 @@
+export const DEFAULT_CI_BRANCHES = ["main", "staging"];
+const SITE_ID_PATTERN = /^[a-z][a-z0-9]*(-[a-z0-9]+)*$/;
+const REPOSITORY_PATTERN = /^https:\/\/github\.com\/[A-Za-z0-9_.-]+\/[A-Za-z0-9_.-]+$/;
+const HOSTED_ZONE_ID_PATTERN = /^Z[A-Z0-9]+$/;
+const HOST_NAME_PATTERN = /^([a-z0-9]([a-z0-9-]*[a-z0-9])?\.)+[a-z]{2,}$/;
+const DOMAIN_PREFIX_PATTERN = /^[a-z0-9]([a-z0-9-]*[a-z0-9])?$/;
+const APP_NAME_PATTERN = /^[A-Za-z0-9][A-Za-z0-9 _.-]*$/;
+const STACK_NAME_PATTERN = /^[A-Za-z][A-Za-z0-9-]{0,127}$/;
+const BRANCH_NAME_PATTERN = /^[A-Za-z0-9][A-Za-z0-9/_.-]*$/;
+const PAPYRUS_VERSION_PATTERN = /^\d+\.\d+\.\d+(-[0-9A-Za-z-]+\.\d+)?$/;
+const GITHUB_OWNER_PATTERN = /^[A-Za-z0-9](?:[A-Za-z0-9]|-(?=[A-Za-z0-9])){0,38}$/;
+const GITHUB_REPO_PATTERN = /^[A-Za-z0-9_.-]+$/;
+const COGNITO_DOMAIN_PREFIX_PATTERN = /^[a-z0-9](?:[a-z0-9-]{0,61}[a-z0-9])?$/;
+const COGNITO_RESERVED_WORDS = ["aws", "amazon", "cognito"];
+const TEMPLATE_MANAGED_ENVIRONMENT_KEYS = ["PAPYRUS_COGNITO_DOMAIN_PREFIX", "PAPYRUS_APPLY_COGNITO_DOMAIN_PREFIX", "PAPYRUS_DISABLE_GOOGLE_OAUTH", "PAPYRUS_REVALIDATE_SECRET_PARAMETER"];
+export function resolveRevalidateSecretParameterName(config) {
+    return `/papyrus/${config.siteId}/revalidate-secret`;
+}
+const LOCAL_DEVELOPMENT_ORIGIN = "http://localhost:3001/";
+function fail(field, problem) {
+    throw new Error(`site.json: ${field} ${problem}`);
+}
+function requireObject(value, field) {
+    if (typeof value !== "object" || value === null || Array.isArray(value)) {
+        fail(field, "must be an object");
+    }
+    return value;
+}
+function requireString(value, field, pattern, patternHint) {
+    if (typeof value !== "string" || value.trim() === "") {
+        fail(field, "must be a non-empty string");
+    }
+    if (pattern && !pattern.test(value)) {
+        fail(field, `is invalid${patternHint ? ` (${patternHint})` : ""}: ${JSON.stringify(value)}`);
+    }
+    return value;
+}
+function optionalString(value, field, pattern, patternHint) {
+    return value === undefined ? undefined : requireString(value, field, pattern, patternHint);
+}
+function requireStringRecord(value, field) {
+    const record = requireObject(value, field);
+    const result = {};
+    for (const [key, entry] of Object.entries(record)) {
+        if (typeof entry !== "string")
+            fail(`${field}.${key}`, "must be a string");
+        result[key] = entry;
+    }
+    return result;
+}
+function rejectUnknownKeys(record, allowed, field) {
+    for (const key of Object.keys(record)) {
+        if (!allowed.includes(key))
+            fail(`${field}.${key}`, `is not a known field (known: ${allowed.join(", ")})`);
+    }
+}
+function parseRedirects(value) {
+    if (value === undefined)
+        return undefined;
+    if (!Array.isArray(value) || value.length === 0)
+        fail("cms.redirects", "must be a non-empty array");
+    return value.map((entry, index) => {
+        const field = `cms.redirects[${index}]`;
+        const record = requireObject(entry, field);
+        rejectUnknownKeys(record, ["source", "status"], field);
+        const source = requireString(record.source, `${field}.source`, HOST_NAME_PATTERN, "host name without scheme or path");
+        const status = record.status ?? 301;
+        if (status !== 301 && status !== 302)
+            fail(`${field}.status`, `must be 301 or 302, got ${JSON.stringify(status)}`);
+        return { source, status };
+    });
+}
+export function resolveRedirectSubDomainPrefix(rootDomain, source) {
+    return source === rootDomain ? "" : source.slice(0, -rootDomain.length - 1);
+}
+export function isStagingEnabled(config) {
+    return config.cms.staging !== false;
+}
+export function resolveCmsHostName(config) {
+    if (!config.cms.domainName)
+        return undefined;
+    return config.cms.domainPrefix ? `${config.cms.domainPrefix}.${config.cms.domainName}` : config.cms.domainName;
+}
+export function resolveStagingDomainName(config) {
+    if (!isStagingEnabled(config))
+        return undefined;
+    if (config.cms.domainPrefix) {
+        return config.cms.stagingDomainPrefix ? `${config.cms.stagingDomainPrefix}.${config.cms.domainName}` : undefined;
+    }
+    if (config.cms.stagingDomainName)
+        return config.cms.stagingDomainName;
+    if (!config.cms.domainName)
+        return undefined;
+    const [, ...rest] = config.cms.domainName.split(".");
+    return ["staging", ...rest].join(".");
+}
+export function resolveStackName(config) {
+    return config.stackName ?? `amplify-app-shell-${config.siteId}`;
+}
+export function resolveStoragePreviewPrefix(config) {
+    return config.storagePreviewPrefix ?? "preview/";
+}
+export function parseSiteConfig(raw) {
+    const record = requireObject(raw, "site");
+    rejectUnknownKeys(record, ["siteId", "repository", "brand", "frontend", "hostedZoneId", "stackName", "cms", "reader", "papyrusVersion", "storagePreviewPrefix", "github"], "site");
+    const siteId = requireString(record.siteId, "siteId", SITE_ID_PATTERN, "kebab-case");
+    const repository = requireString(record.repository, "repository", REPOSITORY_PATTERN, "https://github.com/<org>/<repo>");
+    const brand = requireString(record.brand, "brand");
+    const frontend = requireString(record.frontend, "frontend");
+    if (frontend !== "pretext" && frontend !== "markus-static") {
+        fail("frontend", `must be "pretext" or "markus-static", got ${JSON.stringify(frontend)}`);
+    }
+    const hostedZoneId = optionalString(record.hostedZoneId, "hostedZoneId", HOSTED_ZONE_ID_PATTERN, "Route 53 zone id");
+    const stackName = optionalString(record.stackName, "stackName", STACK_NAME_PATTERN, "CloudFormation stack name");
+    const papyrusVersion = requireString(record.papyrusVersion, "papyrusVersion", PAPYRUS_VERSION_PATTERN, "exact version such as 1.0.0 or 1.0.0-next.1");
+    const storagePreviewPrefix = optionalString(record.storagePreviewPrefix, "storagePreviewPrefix", /^[A-Za-z0-9._-]+\/$/, "must end with /");
+    const cmsRecord = requireObject(record.cms, "cms");
+    rejectUnknownKeys(cmsRecord, ["appName", "domainName", "staging", "cognitoDomainPrefix", "applyCognitoDomainPrefix", "buildComputeType", "environment", "stagingDomainName", "domainPrefix", "stagingDomainPrefix", "redirects"], "cms");
+    const buildComputeType = cmsRecord.buildComputeType;
+    if (buildComputeType !== undefined && buildComputeType !== "STANDARD" && buildComputeType !== "STANDARD_8GB") {
+        fail("cms.buildComputeType", `must be "STANDARD" or "STANDARD_8GB", got ${JSON.stringify(buildComputeType)}`);
+    }
+    if (cmsRecord.staging !== undefined && typeof cmsRecord.staging !== "boolean") {
+        fail("cms.staging", `must be a boolean, got ${JSON.stringify(cmsRecord.staging)}`);
+    }
+    if (cmsRecord.applyCognitoDomainPrefix !== undefined && typeof cmsRecord.applyCognitoDomainPrefix !== "boolean") {
+        fail("cms.applyCognitoDomainPrefix", `must be a boolean, got ${JSON.stringify(cmsRecord.applyCognitoDomainPrefix)}`);
+    }
+    const cms = {
+        appName: optionalString(cmsRecord.appName, "cms.appName", APP_NAME_PATTERN),
+        domainName: optionalString(cmsRecord.domainName, "cms.domainName", HOST_NAME_PATTERN, "host name"),
+        domainPrefix: optionalString(cmsRecord.domainPrefix, "cms.domainPrefix", DOMAIN_PREFIX_PATTERN, "single DNS label"),
+        staging: cmsRecord.staging,
+        cognitoDomainPrefix: requireString(cmsRecord.cognitoDomainPrefix, "cms.cognitoDomainPrefix", COGNITO_DOMAIN_PREFIX_PATTERN, "lowercase letters, digits and hyphens; globally unique per region"),
+        applyCognitoDomainPrefix: cmsRecord.applyCognitoDomainPrefix,
+        buildComputeType: buildComputeType,
+        environment: requireStringRecord(cmsRecord.environment, "cms.environment"),
+        stagingDomainName: optionalString(cmsRecord.stagingDomainName, "cms.stagingDomainName", HOST_NAME_PATTERN, "host name"),
+        stagingDomainPrefix: optionalString(cmsRecord.stagingDomainPrefix, "cms.stagingDomainPrefix", DOMAIN_PREFIX_PATTERN, "single DNS label"),
+        redirects: parseRedirects(cmsRecord.redirects),
+    };
+    const reservedWord = COGNITO_RESERVED_WORDS.find((word) => cms.cognitoDomainPrefix.includes(word));
+    if (reservedWord) {
+        fail("cms.cognitoDomainPrefix", `must not contain "${reservedWord}" (Cognito reserves it): ${JSON.stringify(cms.cognitoDomainPrefix)}`);
+    }
+    for (const key of TEMPLATE_MANAGED_ENVIRONMENT_KEYS) {
+        if (key in cms.environment) {
+            fail(`cms.environment.${key}`, "is managed by the template: Google sign-in is always on, the Cognito domain comes from cms.cognitoDomainPrefix and the revalidation secret parameter is derived from siteId");
+        }
+    }
+    if (cms.staging === false && cms.stagingDomainName) {
+        fail("cms.stagingDomainName", "must not be set when cms.staging is false");
+    }
+    if (cms.stagingDomainName && !cms.domainName) {
+        fail("cms.stagingDomainName", "requires cms.domainName");
+    }
+    if (cms.domainPrefix && !cms.domainName) {
+        fail("cms.domainPrefix", "requires cms.domainName (the root domain)");
+    }
+    if (cms.stagingDomainPrefix && !cms.domainPrefix) {
+        fail("cms.stagingDomainPrefix", "requires cms.domainPrefix");
+    }
+    if (cms.domainPrefix && cms.stagingDomainName) {
+        fail("cms.stagingDomainName", "must not be set with cms.domainPrefix: use cms.stagingDomainPrefix");
+    }
+    if (cms.staging === false && cms.stagingDomainPrefix) {
+        fail("cms.stagingDomainPrefix", "must not be set when cms.staging is false");
+    }
+    if (cms.domainPrefix && cms.staging !== false && !cms.stagingDomainPrefix) {
+        fail("cms.stagingDomainPrefix", "is required when cms.domainPrefix is set and staging is enabled: the staging host is never derived under a shared root domain");
+    }
+    if (cms.domainPrefix && cms.stagingDomainPrefix === cms.domainPrefix) {
+        fail("cms.stagingDomainPrefix", "must differ from cms.domainPrefix");
+    }
+    if (cms.redirects) {
+        if (!cms.domainPrefix)
+            fail("cms.redirects", "requires cms.domainPrefix (redirects target the primary host under a shared root domain)");
+        cms.redirects.forEach((redirect, index) => {
+            const field = `cms.redirects[${index}].source`;
+            const root = cms.domainName;
+            if (redirect.source !== root && !(redirect.source.endsWith(`.${root}`) && DOMAIN_PREFIX_PATTERN.test(redirect.source.slice(0, -root.length - 1)))) {
+                fail(field, `must be the root domain ${root} or a single label under it: ${JSON.stringify(redirect.source)}`);
+            }
+            if (redirect.source === resolveCmsHostName({ cms }))
+                fail(field, "must differ from the primary host");
+            if (redirect.source === resolveStagingDomainName({ cms }))
+                fail(field, "must differ from the staging host");
+        });
+        if (new Set(cms.redirects.map((redirect) => redirect.source)).size !== cms.redirects.length) {
+            fail("cms.redirects", "must not repeat a source");
+        }
+    }
+    let reader;
+    if (record.reader !== undefined) {
+        if (frontend !== "markus-static")
+            fail("reader", `is only allowed when frontend is "markus-static"`);
+        const readerRecord = requireObject(record.reader, "reader");
+        rejectUnknownKeys(readerRecord, ["appName", "domainName", "branchName", "buildCommand", "baseDirectory", "environment"], "reader");
+        reader = {
+            appName: optionalString(readerRecord.appName, "reader.appName", APP_NAME_PATTERN),
+            domainName: optionalString(readerRecord.domainName, "reader.domainName", HOST_NAME_PATTERN, "host name"),
+            branchName: optionalString(readerRecord.branchName, "reader.branchName", BRANCH_NAME_PATTERN),
+            buildCommand: requireString(readerRecord.buildCommand, "reader.buildCommand"),
+            baseDirectory: requireString(readerRecord.baseDirectory, "reader.baseDirectory"),
+            environment: readerRecord.environment === undefined ? undefined : requireStringRecord(readerRecord.environment, "reader.environment"),
+        };
+    }
+    else if (frontend === "markus-static") {
+        fail("reader", `is required when frontend is "markus-static"`);
+    }
+    let github;
+    if (record.github !== undefined) {
+        const githubRecord = requireObject(record.github, "github");
+        rejectUnknownKeys(githubRecord, ["owner", "repo", "branches", "ciCanDeployInfra"], "github");
+        const owner = requireString(githubRecord.owner, "github.owner", GITHUB_OWNER_PATTERN, "plain GitHub login");
+        const repo = requireString(githubRecord.repo, "github.repo", GITHUB_REPO_PATTERN);
+        if (repository !== `https://github.com/${owner}/${repo}`) {
+            fail("github", `owner/repo must match repository ${repository}`);
+        }
+        let branches = cms.staging === false ? DEFAULT_CI_BRANCHES.filter((branch) => branch !== "staging") : DEFAULT_CI_BRANCHES;
+        if (githubRecord.branches !== undefined) {
+            if (!Array.isArray(githubRecord.branches) || githubRecord.branches.length === 0) {
+                fail("github.branches", "must be a non-empty array of branch names");
+            }
+            branches = githubRecord.branches.map((branch, index) => {
+                if (typeof branch === "string" && /[*?]/.test(branch)) {
+                    fail(`github.branches[${index}]`, `must not contain wildcards: ${JSON.stringify(branch)}`);
+                }
+                return requireString(branch, `github.branches[${index}]`, BRANCH_NAME_PATTERN);
+            });
+        }
+        const ciCanDeployInfra = githubRecord.ciCanDeployInfra ?? false;
+        if (typeof ciCanDeployInfra !== "boolean")
+            fail("github.ciCanDeployInfra", "must be a boolean");
+        github = { owner, repo, branches, ciCanDeployInfra: ciCanDeployInfra };
+    }
+    const hasDomain = cms.domainName !== undefined || reader?.domainName !== undefined;
+    if (hasDomain && hostedZoneId === undefined) {
+        fail("hostedZoneId", "is required when cms.domainName or reader.domainName is set");
+    }
+    if (!hasDomain && hostedZoneId !== undefined) {
+        fail("hostedZoneId", "is only allowed when cms.domainName or reader.domainName is set");
+    }
+    const config = {
+        siteId,
+        repository,
+        brand,
+        frontend,
+        hostedZoneId,
+        stackName,
+        cms,
+        reader,
+        papyrusVersion,
+        storagePreviewPrefix,
+        github,
+    };
+    const redirectValue = cms.environment.PAPYRUS_OAUTH_REDIRECT_URLS;
+    if (redirectValue === undefined)
+        fail("cms.environment.PAPYRUS_OAUTH_REDIRECT_URLS", "is required");
+    const redirectUrls = redirectValue.split(",").map((url) => url.trim());
+    const stagingDomainName = resolveStagingDomainName(config);
+    const requiredOrigins = [
+        ...(resolveCmsHostName(config) ? [`https://${resolveCmsHostName(config)}/`] : []),
+        ...(stagingDomainName ? [`https://${stagingDomainName}/`] : []),
+        LOCAL_DEVELOPMENT_ORIGIN,
+    ];
+    for (const origin of requiredOrigins) {
+        if (!redirectUrls.includes(origin)) {
+            fail("cms.environment.PAPYRUS_OAUTH_REDIRECT_URLS", `must include ${origin}`);
+        }
+    }
+    return config;
+}