@anthusai/papyrus 1.0.0-next.8 → 1.0.0

package/amplify/functions/content-actions/handler.py

@@ -4,8 +4,17 @@ import json
 import os
 from typing import Any
 
+from papyrus_content.edge_invalidation import distribution_ids_from_environment, invalidate_revalidated_paths
 from papyrus_content.graphql_authoring import create_authoring_client
 from papyrus_content.markus_renderer.derive import derive_body
+from papyrus_content.projection.deploy_render import deploy_render, drift_metric_line
+from papyrus_content.projection.engine import project, project_all, project_item_pages
+from papyrus_content.projection.runtime import (
+    DEAD_LETTER_QUEUE_ENV,
+    context_from_environment,
+    projection_configured,
+    public_item_url,
+)
 from papyrus_content.rebuild_trigger import (
     DEFAULT_STAGING_BRANCH,
     reader_target_from_environment,
@@ -56,6 +65,127 @@ def derive_markus_action(arguments: dict) -> dict:
     return response
 
 
+PROJECTION_TASK_KEY = "projectionTask"
+
+
+class ProjectionTaskFailed(Exception):
+    """Raised by an asynchronous projection task so Lambda retries it and, finally, sends it to the dead letter queue."""
+
+
+def send_to_projection_dead_letter_queue(task: dict, error: str) -> None:
+    queue_url = (os.environ.get(DEAD_LETTER_QUEUE_ENV) or "").strip()
+    if not queue_url:
+        return
+    try:
+        import boto3
+
+        boto3.client("sqs").send_message(
+            QueueUrl=queue_url, MessageBody=json.dumps({PROJECTION_TASK_KEY: task, "error": error})
+        )
+    except Exception:  # noqa: BLE001 - the dead letter is best effort; the response already reports the failure
+        pass
+
+
+def schedule_projection_task(task: dict, error: str) -> bool:
+    """Run a projection task later, in this same function, as an asynchronous invocation.
+
+    The function has an on-failure destination (the dead letter queue), so a task
+    that keeps failing ends up there for ``papyrus ops content project --reconcile``.
+    """
+    function_name = (os.environ.get("AWS_LAMBDA_FUNCTION_NAME") or "").strip()
+    if not function_name:
+        send_to_projection_dead_letter_queue(task, error)
+        return False
+    try:
+        import boto3
+
+        boto3.client("lambda").invoke(
+            FunctionName=function_name, InvocationType="Event", Payload=json.dumps({PROJECTION_TASK_KEY: task}).encode("utf-8")
+        )
+        return True
+    except Exception as scheduling_error:  # noqa: BLE001 - fall back to the dead letter queue
+        send_to_projection_dead_letter_queue(task, f"{error}; scheduling failed: {scheduling_error}")
+        return False
+
+
+def projection_context(client):
+    context = context_from_environment(client)
+    context.defer_follow_up = True
+    return context
+
+
+def project_item_action(client, item_id: str, *, unpublished: bool) -> dict:
+    if not projection_configured():
+        return {}
+    liveness = {} if unpublished else {"live": False}
+    task = {"task": "item", "itemId": item_id, "unpublished": unpublished}
+    try:
+        report = project(projection_context(client), item_id, unpublished=unpublished)
+    except Exception as error:  # noqa: BLE001 - a projection failure never fails the save
+        message = f"{type(error).__name__}: {error}"
+        schedule_projection_task(task, message)
+        return {**liveness, "projected": False, "paths": [], "error": message}
+    response = {"projected": report.ok, "paths": [*report.written, *report.deleted]}
+    if not unpublished:
+        response["live"] = report.ok
+        url = public_item_url(os.environ, report.item_paths)
+        if url:
+            response["url"] = url
+    if not report.ok:
+        message = "; ".join(report.errors)
+        schedule_projection_task(task, message)
+        response["error"] = message
+    if report.unpurged:
+        response["edgePurged"] = False
+        schedule_unpurged_invalidation(report.unpurged)
+    if report.follow_up_item_pages:
+        schedule_projection_task({"task": "item-pages", "exceptItemId": item_id}, "follow-up")
+    return response
+
+
+def schedule_unpurged_invalidation(keys: list[str]) -> None:
+    schedule_projection_task({"task": "invalidate", "keys": keys}, "edge invalidation failed")
+
+
+def run_deploy_render_task(client) -> dict:
+    """Render every published page after a backend deploy, then report drift (a dry run: nothing is deleted)."""
+    context = projection_context(client)
+    report = deploy_render(context)
+    print(drift_metric_line(report))
+    if report.render.unpurged:
+        schedule_unpurged_invalidation(report.render.unpurged)
+    if not report.ok:
+        raise ProjectionTaskFailed("; ".join([*report.render.errors, *report.drift.errors]))
+    return report.to_dict()
+
+
+def run_projection_task(task: dict) -> dict:
+    """An asynchronous projection task. Raising makes Lambda retry it, then send the event to the dead letter queue."""
+    client, _claims = create_authoring_client()
+    if task.get("task") == "item-pages":
+        report = project_item_pages(projection_context(client), except_item_id=task.get("exceptItemId"))
+    elif task.get("task") == "item":
+        report = project(projection_context(client), task["itemId"], unpublished=bool(task.get("unpublished")))
+        if report.follow_up_item_pages:
+            schedule_projection_task({"task": "item-pages", "exceptItemId": task["itemId"]}, "follow-up")
+    elif task.get("task") == "all":
+        report = project_all(projection_context(client))
+    elif task.get("task") == "deploy-render":
+        return run_deploy_render_task(client)
+    elif task.get("task") == "invalidate":
+        invalidate = projection_context(client).invalidate
+        if invalidate is None:
+            return {"ok": True, "paths": []}
+        return {"ok": True, "paths": invalidate(list(task["keys"]))}
+    else:
+        raise ProjectionTaskFailed(f"Unknown projection task {task.get('task')!r}")
+    if report.unpurged:
+        schedule_unpurged_invalidation(report.unpurged)
+    if not report.ok:
+        raise ProjectionTaskFailed("; ".join(report.errors))
+    return {"ok": True, "paths": [*report.written, *report.deleted]}
+
+
 def save_item_draft_action(arguments: dict, actor: str) -> dict:
     client, _claims = create_authoring_client()
     fields = ItemFields(
@@ -68,7 +198,7 @@ def save_item_draft_action(arguments: dict, actor: str) -> dict:
         id=arguments.get("id"),
     )
     record = save_item(client, fields, actor=actor, expected_content_hash=arguments.get("expectedContentHash"))
-    return {
+    response = {
         "ok": True,
         "item": {
             "id": record["id"],
@@ -78,6 +208,11 @@ def save_item_draft_action(arguments: dict, actor: str) -> dict:
             "versionNumber": record.get("versionNumber"),
         },
     }
+    if record["status"] == "published" and projection_configured():
+        published = publish_item(client, record["id"], actor=actor)
+        response["item"]["versionNumber"] = published.version_number
+        response.update(project_item_action(client, record["id"], unpublished=False))
+    return response
 
 
 def site_triggers_for(client, item_id: str) -> dict:
@@ -90,6 +225,9 @@ def site_triggers_for(client, item_id: str) -> dict:
             slugs = [item["slug"]] if item.get("slug") else []
             revalidated = trigger_pretext_revalidation(slugs, None, base_url=revalidate_base_url)
             triggers["revalidated"] = revalidated if revalidated is not None else {"ok": False, "reason": "not-configured"}
+            distribution_ids = distribution_ids_from_environment(os.environ)
+            if distribution_ids and revalidated is not None:
+                triggers["edgeInvalidated"] = invalidate_revalidated_paths(distribution_ids, revalidated)
         except Exception as error:  # noqa: BLE001 - a trigger failure never fails the publish
             triggers["revalidated"] = {"ok": False, "error": f"{type(error).__name__}: {error}"}
     if reader_app_id:
@@ -108,6 +246,7 @@ def publish_item_action(arguments: dict, actor: str) -> dict:
     }
     if result.changed:
         response.update(site_triggers_for(client, arguments["id"]))
+    response.update(project_item_action(client, arguments["id"], unpublished=False))
     return response
 
 
@@ -117,6 +256,7 @@ def unpublish_item_action(arguments: dict, actor: str) -> dict:
     response = {"ok": True, "changed": result.changed}
     if result.changed:
         response.update(site_triggers_for(client, arguments["id"]))
+    response.update(project_item_action(client, arguments["id"], unpublished=True))
     return response
 
 
@@ -130,6 +270,8 @@ def request_staging_build_action() -> dict:
 
 
 def handler(event, context):
+    if PROJECTION_TASK_KEY in event:
+        return run_projection_task(event[PROJECTION_TASK_KEY])
     field = event["fieldName"]
     arguments = parse_input(event["arguments"]["input"])
     actor = actor_from_event(event)

package/amplify/functions/content-actions/requirements.txt

@@ -1,4 +1,5 @@
 PyYAML>=6.0.2,<7
 citeproc-py>=0.8.2,<1
 anthus-markus==0.5.1
-Pillow>=10,<12
+Pillow>=11.3,<12
+awscrt>=0.23,<1

package/amplify/functions/content-actions/resource.js

@@ -7,11 +7,15 @@ import { fileURLToPath } from "node:url";
 import { pythonLambdaCode } from "../shared/python-bundle.js";
 const dirname = path.dirname(fileURLToPath(import.meta.url));
 const projectRoot = path.resolve(dirname, "../../..");
-export const contentActionsRequirements = ["PyYAML>=6.0.2,<7", "citeproc-py>=0.8.2,<1", "anthus-markus==0.5.1", "Pillow>=10,<12"];
+export const contentActionsRequirements = ["PyYAML>=6.0.2,<7", "citeproc-py>=0.8.2,<1", "anthus-markus==0.5.1", "Pillow>=11.3,<12", "awscrt>=0.23,<1"];
 function installCheckoutRequirements(outputDir) {
     const requirementsPath = path.join(projectRoot, "amplify/functions/content-actions/requirements.txt");
     execSync(`python3 -m pip install -r "${requirementsPath}" -t "${outputDir}" --no-cache-dir --platform manylinux2014_aarch64 --implementation cp --python-version 3.12 --only-binary=:all: --ignore-requires-python`, { cwd: projectRoot, stdio: "inherit" });
 }
+let siteFilesForNextContentActionsBundle;
+export function setSiteFilesForContentActionsBundle(siteFiles) {
+    siteFilesForNextContentActionsBundle = siteFiles;
+}
 export const contentActions = defineFunction((scope) => {
     return new Function(scope, "papyrus-content-actions", {
         runtime: Runtime.PYTHON_3_12,
@@ -25,6 +29,7 @@ export const contentActions = defineFunction((scope) => {
             requirements: contentActionsRequirements,
             noDeps: true,
             checkoutExtras: installCheckoutRequirements,
+            ...(siteFilesForNextContentActionsBundle !== undefined ? { siteFiles: siteFilesForNextContentActionsBundle } : {}),
         }, [
             "bash",
             "-c",

package/amplify/functions/content-actions/resource.ts

@@ -5,12 +5,12 @@ import { Construct } from "constructs";
 import { execSync } from "node:child_process";
 import path from "node:path";
 import { fileURLToPath } from "node:url";
-import { pythonLambdaCode } from "../shared/python-bundle";
+import { pythonLambdaCode, type SiteBundleFile } from "../shared/python-bundle";
 
 const dirname = path.dirname(fileURLToPath(import.meta.url));
 const projectRoot = path.resolve(dirname, "../../..");
 
-export const contentActionsRequirements = ["PyYAML>=6.0.2,<7", "citeproc-py>=0.8.2,<1", "anthus-markus==0.5.1", "Pillow>=10,<12"];
+export const contentActionsRequirements = ["PyYAML>=6.0.2,<7", "citeproc-py>=0.8.2,<1", "anthus-markus==0.5.1", "Pillow>=11.3,<12", "awscrt>=0.23,<1"];
 
 function installCheckoutRequirements(outputDir: string): void {
   const requirementsPath = path.join(projectRoot, "amplify/functions/content-actions/requirements.txt");
@@ -20,6 +20,12 @@ function installCheckoutRequirements(outputDir: string): void {
   );
 }
 
+let siteFilesForNextContentActionsBundle: SiteBundleFile[] | undefined;
+
+export function setSiteFilesForContentActionsBundle(siteFiles: SiteBundleFile[] | undefined): void {
+  siteFilesForNextContentActionsBundle = siteFiles;
+}
+
 export const contentActions = defineFunction(
   (scope: Construct) => {
     return new Function(scope, "papyrus-content-actions", {
@@ -35,6 +41,7 @@ export const contentActions = defineFunction(
           requirements: contentActionsRequirements,
           noDeps: true,
           checkoutExtras: installCheckoutRequirements,
+          ...(siteFilesForNextContentActionsBundle !== undefined ? { siteFiles: siteFilesForNextContentActionsBundle } : {}),
         },
         [
           "bash",

package/amplify/functions/renditions/handler.py

@@ -0,0 +1,120 @@
+from __future__ import annotations
+
+import json
+import os
+import time
+from pathlib import Path
+from typing import Any
+
+from papyrus_content.projection.runtime import SITE_BUCKET_ENV, SITE_STATIC_DIRECTORY_ENV
+from papyrus_content.renditions import (
+    RenditionSettings,
+    S3RenditionStore,
+    make_renditions,
+    media_originals_enabled,
+    meta_key,
+    original_site_key,
+    ORIGINAL_CACHE_CONTROL,
+    settings_from_static_directory,
+    source_from_media_key,
+)
+
+_loaded: dict[str, Any] = {}
+
+
+def configured_settings() -> RenditionSettings | None:
+    if "settings" not in _loaded:
+        static_directory = (os.environ.get(SITE_STATIC_DIRECTORY_ENV) or "").strip()
+        _loaded["settings"] = settings_from_static_directory(Path(static_directory) if static_directory else None)
+    return _loaded["settings"]
+
+
+def originals_enabled() -> bool:
+    if "originals" not in _loaded:
+        static_directory = (os.environ.get(SITE_STATIC_DIRECTORY_ENV) or "").strip()
+        _loaded["originals"] = media_originals_enabled(Path(static_directory) if static_directory else None)
+    return _loaded["originals"]
+
+
+def site_store() -> S3RenditionStore:
+    if "store" not in _loaded:
+        _loaded["store"] = S3RenditionStore(os.environ[SITE_BUCKET_ENV])
+    return _loaded["store"]
+
+
+def s3_client():
+    if "s3" not in _loaded:
+        import boto3
+
+        _loaded["s3"] = boto3.client("s3")
+    return _loaded["s3"]
+
+
+def media_objects(event: dict) -> list[tuple[str, str]]:
+    if event.get("source") == "aws.s3" and "detail" in event:
+        detail = event["detail"]
+        return [(detail["bucket"]["name"], detail["object"]["key"])]
+    if "bucket" in event and "key" in event:
+        return [(event["bucket"], event["key"])]
+    raise ValueError("The event is neither an S3 object event nor a {bucket, key} request.")
+
+
+def render_media_object(
+    settings: RenditionSettings | None,
+    bucket: str,
+    key: str,
+    *,
+    originals: bool = False,
+    skip_existing: bool = False,
+    dry_run: bool = False,
+) -> dict:
+    source = source_from_media_key(key) if settings is not None else None
+    original_key = original_site_key(key) if originals else None
+    if source is None and original_key is None:
+        return {"key": key, "action": "ignored", "reason": "not an image under media/"}
+    if skip_existing:
+        renditions_exist = source is None or site_store().get(meta_key(settings.pipeline, source)) is not None
+        original_exists = original_key is None or site_store().get(original_key) is not None
+        if renditions_exist and original_exists:
+            return {"key": key, "source": source or original_key, "action": "skipped-existing"}
+    if dry_run:
+        return {"key": key, "source": source or original_key, "action": "would-render" if source else "would-copy"}
+    started = time.perf_counter()
+    data = s3_client().get_object(Bucket=bucket, Key=key)["Body"].read()
+    downloaded = time.perf_counter()
+    if original_key is not None:
+        site_store().put(original_key, data, cache_control=ORIGINAL_CACHE_CONTROL)
+    if source is None:
+        return {"key": key, "source": original_key, "action": "copied", "written": 1, "sourceBytes": len(data)}
+    result = make_renditions(settings, site_store(), source, data)
+    finished = time.perf_counter()
+    return {
+        "key": key,
+        "source": source,
+        "action": "rendered",
+        "kind": result["kind"],
+        "written": result["written"] + (1 if original_key is not None else 0),
+        "sourceBytes": len(data),
+        "downloadMilliseconds": round((downloaded - started) * 1000),
+        "renditionMilliseconds": round((finished - downloaded) * 1000),
+    }
+
+
+def handler(event, context):
+    settings = configured_settings()
+    originals = originals_enabled()
+    if settings is None and not originals:
+        return {"ok": True, "results": [], "skipped": "this site has no images or media settings in projection.json"}
+    results = [
+        render_media_object(
+            settings,
+            bucket,
+            key,
+            originals=originals,
+            skip_existing=event.get("skipExisting") is True,
+            dry_run=event.get("dryRun") is True,
+        )
+        for bucket, key in media_objects(event)
+    ]
+    print(json.dumps({"renditions": results}))
+    return {"ok": True, "results": results}

package/amplify/functions/renditions/requirements.txt

@@ -0,0 +1,4 @@
+PyYAML>=6.0.2,<7
+citeproc-py>=0.8.2,<1
+anthus-markus==0.5.1
+Pillow>=11.3,<12

package/amplify/functions/shared/python-bundle.js

@@ -1,5 +1,6 @@
 import { AssetHashType, DockerImage } from "aws-cdk-lib";
 import { Code, Runtime } from "aws-cdk-lib/aws-lambda";
+import { createHash } from "node:crypto";
 import { execFileSync } from "node:child_process";
 import fs from "node:fs";
 import path from "node:path";
@@ -41,6 +42,39 @@ export function toPep440(version) {
         throw new Error(`Cannot map ${version} to a PEP 440 version`);
     return m[2] === undefined ? m[1] : `${m[1]}.dev${m[2]}`;
 }
+function isBytecodeArtifact(sourcePath) {
+    return sourcePath.split(path.sep).includes("__pycache__") || sourcePath.endsWith(".pyc");
+}
+export function copySiteFiles(outputDir, siteFiles) {
+    for (const siteFile of siteFiles ?? []) {
+        const sourcePath = path.resolve(process.cwd(), siteFile.from);
+        if (!fs.existsSync(sourcePath))
+            throw new Error(`Site file to bundle does not exist: ${siteFile.from}`);
+        const destinationPath = path.join(outputDir, siteFile.to);
+        fs.mkdirSync(path.dirname(destinationPath), { recursive: true });
+        fs.cpSync(sourcePath, destinationPath, { recursive: true, filter: (candidate) => !isBytecodeArtifact(candidate) });
+    }
+}
+function listFilesRecursively(root) {
+    if (fs.statSync(root).isFile())
+        return [root];
+    return fs.readdirSync(root).sort().flatMap((entry) => listFilesRecursively(path.join(root, entry)))
+        .filter((candidate) => !isBytecodeArtifact(candidate));
+}
+export function siteFilesContentHash(siteFiles) {
+    const hash = createHash("sha256");
+    for (const siteFile of siteFiles ?? []) {
+        const sourcePath = path.resolve(process.cwd(), siteFile.from);
+        hash.update(`${siteFile.to}\0`);
+        if (!fs.existsSync(sourcePath))
+            continue;
+        for (const filePath of listFilesRecursively(sourcePath)) {
+            hash.update(`${path.relative(sourcePath, filePath)}\0`);
+            hash.update(fs.readFileSync(filePath));
+        }
+    }
+    return hash.digest("hex").slice(0, 16);
+}
 function pipSpec() {
     return (process.env.PAPYRUS_PIP_SPEC ?? "").trim() || `papyrus-newsroom==${toPep440(papyrusVersion())}`;
 }
@@ -77,6 +111,7 @@ function bundleFromPip(outputDir, options) {
         ], { stdio: "inherit" });
     }
     fs.copyFileSync(path.join(packageRoot, "amplify/functions", options.functionDir, "handler.py"), path.join(outputDir, "handler.py"));
+    copySiteFiles(outputDir, options.siteFiles);
     if (options.corpora) {
         const corporaDir = path.join(outputDir, "corpora");
         fs.mkdirSync(corporaDir, { recursive: true });
@@ -96,6 +131,7 @@ export function bundleFromCheckout(outputDir, options) {
         fs.cpSync(path.join(packageRoot, "src", module), path.join(outputDir, module), { recursive: true });
     }
     options.checkoutExtras?.(outputDir);
+    copySiteFiles(outputDir, options.siteFiles);
 }
 /**
  * CDK Code for a Python Lambda. In package mode the asset hash is derived
@@ -103,14 +139,18 @@ export function bundleFromCheckout(outputDir, options) {
  */
 export function pythonLambdaCode(options, dockerCommand) {
     const packageMode = isPackageMode();
+    const hasSiteFiles = (options.siteFiles ?? []).length > 0;
+    const siteFilesSuffix = hasSiteFiles ? `:site-${siteFilesContentHash(options.siteFiles)}` : "";
     return Code.fromAsset(packageRoot, {
         ...(packageMode
             ? {
                 assetHashType: AssetHashType.CUSTOM,
-                assetHash: `${options.functionDir}:${pipSpec()}:${(options.requirements ?? []).join(",")}`
+                assetHash: `${options.functionDir}:${pipSpec()}:${(options.requirements ?? []).join(",")}${siteFilesSuffix}`
                     .replace(/[^a-zA-Z0-9._:=,-]/g, "_"),
             }
-            : {}),
+            : hasSiteFiles
+                ? { assetHashType: AssetHashType.OUTPUT }
+                : {}),
         bundling: {
             image: Runtime.PYTHON_3_12.bundlingImage ?? DockerImage.fromRegistry("public.ecr.aws/sam/build-python3.12"),
             local: {

package/amplify/functions/shared/python-bundle.ts

@@ -1,5 +1,6 @@
 import { AssetHashType, DockerImage } from "aws-cdk-lib";
 import { Code, Runtime } from "aws-cdk-lib/aws-lambda";
+import { createHash } from "node:crypto";
 import { execFileSync } from "node:child_process";
 import fs from "node:fs";
 import path from "node:path";
@@ -57,8 +58,46 @@ export type PythonBundleOptions = {
   noDeps?: boolean;
   /** Copy `<cwd>/corpora/*.yml` into the asset (publication-owned steering config). */
   corpora?: boolean;
+  /** Site repo files copied into the asset; `from` is relative to the current working directory, `to` to the asset root. A directory is copied recursively. */
+  siteFiles?: SiteBundleFile[];
 };
 
+export type SiteBundleFile = { from: string; to: string };
+
+function isBytecodeArtifact(sourcePath: string): boolean {
+  return sourcePath.split(path.sep).includes("__pycache__") || sourcePath.endsWith(".pyc");
+}
+
+export function copySiteFiles(outputDir: string, siteFiles: SiteBundleFile[] | undefined): void {
+  for (const siteFile of siteFiles ?? []) {
+    const sourcePath = path.resolve(process.cwd(), siteFile.from);
+    if (!fs.existsSync(sourcePath)) throw new Error(`Site file to bundle does not exist: ${siteFile.from}`);
+    const destinationPath = path.join(outputDir, siteFile.to);
+    fs.mkdirSync(path.dirname(destinationPath), { recursive: true });
+    fs.cpSync(sourcePath, destinationPath, { recursive: true, filter: (candidate) => !isBytecodeArtifact(candidate) });
+  }
+}
+
+function listFilesRecursively(root: string): string[] {
+  if (fs.statSync(root).isFile()) return [root];
+  return fs.readdirSync(root).sort().flatMap((entry) => listFilesRecursively(path.join(root, entry)))
+    .filter((candidate) => !isBytecodeArtifact(candidate));
+}
+
+export function siteFilesContentHash(siteFiles: SiteBundleFile[] | undefined): string {
+  const hash = createHash("sha256");
+  for (const siteFile of siteFiles ?? []) {
+    const sourcePath = path.resolve(process.cwd(), siteFile.from);
+    hash.update(`${siteFile.to}\0`);
+    if (!fs.existsSync(sourcePath)) continue;
+    for (const filePath of listFilesRecursively(sourcePath)) {
+      hash.update(`${path.relative(sourcePath, filePath)}\0`);
+      hash.update(fs.readFileSync(filePath));
+    }
+  }
+  return hash.digest("hex").slice(0, 16);
+}
+
 function pipSpec(): string {
   return (process.env.PAPYRUS_PIP_SPEC ?? "").trim() || `papyrus-newsroom==${toPep440(papyrusVersion())}`;
 }
@@ -107,6 +146,7 @@ function bundleFromPip(outputDir: string, options: PythonBundleOptions): void {
     path.join(packageRoot, "amplify/functions", options.functionDir, "handler.py"),
     path.join(outputDir, "handler.py"),
   );
+  copySiteFiles(outputDir, options.siteFiles);
   if (options.corpora) {
     const corporaDir = path.join(outputDir, "corpora");
     fs.mkdirSync(corporaDir, { recursive: true });
@@ -129,6 +169,7 @@ export function bundleFromCheckout(outputDir: string, options: PythonBundleOptio
     fs.cpSync(path.join(packageRoot, "src", module), path.join(outputDir, module), { recursive: true });
   }
   options.checkoutExtras?.(outputDir);
+  copySiteFiles(outputDir, options.siteFiles);
 }
 
 /**
@@ -137,14 +178,18 @@ export function bundleFromCheckout(outputDir: string, options: PythonBundleOptio
  */
 export function pythonLambdaCode(options: PythonBundleOptions, dockerCommand: string[]): Code {
   const packageMode = isPackageMode();
+  const hasSiteFiles = (options.siteFiles ?? []).length > 0;
+  const siteFilesSuffix = hasSiteFiles ? `:site-${siteFilesContentHash(options.siteFiles)}` : "";
   return Code.fromAsset(packageRoot, {
     ...(packageMode
       ? {
           assetHashType: AssetHashType.CUSTOM,
-          assetHash: `${options.functionDir}:${pipSpec()}:${(options.requirements ?? []).join(",")}`
+          assetHash: `${options.functionDir}:${pipSpec()}:${(options.requirements ?? []).join(",")}${siteFilesSuffix}`
             .replace(/[^a-zA-Z0-9._:=,-]/g, "_"),
         }
-      : {}),
+      : hasSiteFiles
+        ? { assetHashType: AssetHashType.OUTPUT }
+        : {}),
     bundling: {
       image: Runtime.PYTHON_3_12.bundlingImage ?? DockerImage.fromRegistry("public.ecr.aws/sam/build-python3.12"),
       local: {

package/amplify/functions/shared/reference-curation-metadata.ts

@@ -0,0 +1,29 @@
+/**
+ * Metadata stored with an editor's reference curation Message. When the
+ * relevance cyclotron decided the reference, the review records which
+ * decision it answered and whether its explanation may be shared (for the
+ * Cyclotron marketing recording). Both are optional.
+ */
+export type ReferenceCurationMetadataInput = {
+  action: string
+  curationStatus: string
+  reasonCode: string | null
+  referenceId: string
+  referenceLineageId: string
+  decisionRelationId?: string | null
+  shareable?: boolean | null
+}
+
+export function referenceCurationMetadata(input: ReferenceCurationMetadataInput): Record<string, unknown> {
+  const decisionRelationId = input.decisionRelationId?.trim() || null
+  return {
+    action: input.action,
+    curationStatus: input.curationStatus,
+    reasonCode: input.reasonCode,
+    curationReasonCode: input.reasonCode,
+    referenceId: input.referenceId,
+    referenceLineageId: input.referenceLineageId,
+    ...(decisionRelationId ? {decisionRelationId} : {}),
+    ...(decisionRelationId ? {shareable: input.shareable === true} : {}),
+  }
+}