Fog

Fog Lambda runtime upgrade with ARM64 preservation

At a glance

  • Required architecture parameter selects both Lambda architecture and matching artifact key; no silent x86_64 default.
  • Both bootstrap ZIPs built once; native Linux jobs execute the same uploaded artifacts.
  • Main-only publisher retains existing role and legacy aliases and waits for both architecture checks.
  • Exact deployed template/source equivalence remains unverified due to denied reads. Separate legacy HelloWorld trigger source remains missing.

Verdict

Native x86_64 and ARM64 accepted

Both packages build and six local Python 3.14 tests pass; actionlint and cfn-lint pass with baseline warning exclusions. Four independent reviewers found no issues. Final head f1fc525 passes x86_64 build/tests/lint and native ARM64 smoke in both PR and feature-push runs using the same uploaded archives; publisher skipped. Existing automated Claude review fails separately; local independent reviewers completed with no findings.

Review findings

2 raised · 2 fixed · 0 skipped

Jump to findings →

Tests

Pass rate: n/a

New tests: 7

Diff coverage: n/a

Jump to tests →

Three-level explanation

Different processors need different programs. Both deployed processor types now get the matching report runner; choosing a processor is required so an upgrade cannot silently switch it.

The package script maps AWS x86_64/arm64 names to Go targets. The SAM parameter controls architecture and S3 key. CI builds both once and downloads the same packages for native ARM verification.

ELF machine and static interpreter checks establish archive targets. Runtime API error exchange establishes initialization on matching Linux runners. Main-only publication waits for both jobs and preserves legacy Go RPC and unqualified x86 aliases. Actual AWS templates remain unreadable.

Review findings

SeverityAreaFindingResolution
majorArchitecture coverageDeployed Demo report is ARM64 but original package and template were x86_64 only.Build both targets and require an explicit parameter bound to architecture-qualified artifacts. Native ARM CI is added and gates main publication.
majorPublication scopeInitial removal of existing S3 publishing exceeded the upgrade task.Restore publishing only for main pushes, retain existing role and legacy objects, publish bootstrap under separate keys.

Tests

Source: local run at 2026-10-17T12:46:09.703476+00:00 · snapshot f1fc525f7041908a772735c0634dd29d23b794cf

Baseline: none

Execution: passed · JUnit: none · Coverage: none · Baseline: absent

Coverage scope: as the project configures it

No test results

A required tool is missing.

New and removed tests

Derived by declaration name, from the diff (no baseline run).

Blast radius

Files that import a changed file on the left, changed files in the centre, files a changed file imports on the right. Snapshot working-tree against base 102f9aabe414ecbdf7139b6d14d0aabfe11bac3a.

Dependents none found Changed Dependencies edges at package granularity . github.com/ArjenSchwarz/fog scripts test/lambda github.com/ArjenSchwarz/fog/cmd .gitignore.gitignore MakefileMakefile go.modgo.mod go.sumgo.sum main.gomain.go main_test.gomain_test.go scripts/package-lambda.shscripts/package-lambda.sh test/lambda/test_package.pytest/lambda/test_package.py cmd/constants.go cmd/demo.go cmd/demosettings.go cmd/dependencies.go cmd/deploy.go cmd/deploy_helpers.go cmd/deploy_output.go cmd/describe.go cmd/describe_changeset.go cmd/drift.go cmd/exports.go cmd/flaggroups.go cmd/groups.go cmd/helpers.go cmd/history.go cmd/output_helpers.go cmd/report.go cmd/resources.go cmd/root.go cmd/tables.go cmd/version.go….com/ArjenSchwarz/fog/cmd (21 files)
addedmodifieddeletedrenamedunchangedcollapsed package group or +N more⚑N test files with an edge to the node

Collapsed nodes

Per-file diffs

19 files: 10 code · 7 docs · 2 other. Click to expand.

Code (10)

.github/workflows/push.yml Modified
diff --git a/.github/workflows/push.yml b/.github/workflows/push.ymlindex 0b72ab1..f0d2513 100644--- a/.github/workflows/push.yml+++ b/.github/workflows/push.yml@@ -1,30 +1,86 @@-on: [push]+name: Test and Build+on: [push, pull_request]++permissions:+  contents: read  jobs:   build-and-test:-    name: Test and Build     runs-on: ubuntu-latest-    permissions:-      id-token: write-      contents: read     steps:-      - uses: actions/checkout@v5-      - uses: actions/setup-go@v6+      - uses: actions/checkout@v7.0.1+      - uses: actions/setup-go@v7.0.0         with:-          go-version: '1.25' # The Go version to download (if necessary) and use.+          go-version-file: go.mod+      - uses: actions/setup-python@v7.0.0+        with:+          python-version: '3.14'       - name: Run tests         run: go test ./... -v       - name: Run linter-        uses: golangci/golangci-lint-action@v8+        uses: golangci/golangci-lint-action@v9.3.0         with:-          version: latest+          version: v2.14.0           skip-cache: true-      - name: Build file-        run: GOOS=linux GOARCH=amd64 go build -o fog && zip unstable.zip fog+      - name: Package Lambda+        run: make package-lambda+      - name: Verify package and inline trigger+        run: python3 -m unittest discover -s test/lambda -v+      - name: Save Lambda package+        uses: actions/upload-artifact@v7.0.2+        with:+          name: fog-lambda-al2023-${{ github.sha }}+          path: dist/lambda*.zip+          if-no-files-found: error+  lambda-arm64-smoke:+    needs: build-and-test+    runs-on: ubuntu-24.04-arm+    steps:+      - uses: actions/checkout@v7.0.1+      - uses: actions/setup-python@v7.0.0+        with:+          python-version: '3.14'+      - uses: actions/download-artifact@v8.0.2+        with:+          name: fog-lambda-al2023-${{ github.sha }}+          path: dist+      - name: Verify ARM64 archive and inline trigger+        run: python3 -m unittest discover -s test/lambda -v+  publish-lambda:+    if: github.event_name == 'push' && github.ref == 'refs/heads/main'+    needs: [build-and-test, lambda-arm64-smoke]+    runs-on: ubuntu-latest+    permissions:+      contents: read+      id-token: write+    steps:+      - uses: actions/checkout@v7.0.1+      - uses: actions/setup-go@v7.0.0+        with:+          go-version-file: go.mod+      - uses: actions/download-artifact@v8.0.2+        with:+          name: fog-lambda-al2023-${{ github.sha }}+          path: dist+      # Preserve legacy consumers until their runtime migration is deployed.+      - name: Build legacy Lambda archive+        if: github.event_name == 'push' && github.ref == 'refs/heads/main'+        run: |+          legacy_dir="$(mktemp -d)"+          trap 'rm -rf "$legacy_dir"' EXIT+          CGO_ENABLED=0 GOOS=linux GOARCH=amd64 go build -trimpath -o "$legacy_dir/fog" .+          (cd "$legacy_dir" && zip -q -X unstable.zip fog)+          mv "$legacy_dir/unstable.zip" dist/unstable-legacy.zip       - name: Configure AWS Credentials-        uses: aws-actions/configure-aws-credentials@v2+        if: github.event_name == 'push' && github.ref == 'refs/heads/main'+        uses: aws-actions/configure-aws-credentials@v6.3.0         with:           role-to-assume: arn:aws:iam::613864977396:role/github-oidc-FogS3DeploymentsRole-EQO45UDOAHSL           aws-region: us-east-1-      - name: Copy to S3 bucket-        run: aws s3 cp unstable.zip s3://public.ig.nore.me/fog/unstable.zip+      - name: Publish Lambda archives+        if: github.event_name == 'push' && github.ref == 'refs/heads/main'+        run: |+          aws s3 cp dist/unstable-legacy.zip s3://public.ig.nore.me/fog/unstable.zip+          aws s3 cp dist/lambda-x86_64.zip s3://public.ig.nore.me/fog/al2023/unstable.zip+          aws s3 cp dist/lambda-x86_64.zip s3://public.ig.nore.me/fog/al2023/x86_64/unstable.zip+          aws s3 cp dist/lambda-arm64.zip s3://public.ig.nore.me/fog/al2023/arm64/unstable.zip
.github/workflows/release.yaml Modified
diff --git a/.github/workflows/release.yaml b/.github/workflows/release.yamlindex 6ce43e8..feb2ed3 100644--- a/.github/workflows/release.yaml+++ b/.github/workflows/release.yaml@@ -3,6 +3,9 @@ on:     types:       - published +permissions:+  contents: write+ jobs:   releases-matrix:     name: Release Go Binary@@ -13,33 +16,32 @@ jobs:         goos: [linux, windows, darwin]         goarch: [amd64, arm64]     steps:-    - uses: actions/checkout@v5+    - uses: actions/checkout@v7.0.1     - name: Set APP_VERSION env-      run: echo APP_VERSION=$(echo ${GITHUB_REF} | rev | cut -d'/' -f 1 | rev ) >> ${GITHUB_ENV}-    - uses: wangyoucao577/go-release-action@v1.53+      run: echo "APP_VERSION=${GITHUB_REF_NAME}" >> "$GITHUB_ENV"+    - uses: wangyoucao577/go-release-action@v1.55       with:+        goversion: "1.27.2"         github_token: ${{ secrets.GITHUB_TOKEN }}         goos: ${{ matrix.goos }}         goarch: ${{ matrix.goarch }}         binary_name: "fog"         ldflags: "-s -w -X 'github.com/ArjenSchwarz/fog/cmd.Version=${{ env.APP_VERSION}}'"-  # s3release:-  #   name: Publish Lambda zipfile-  #   runs-on: ubuntu-latest-  #   steps:-  #     - uses: actions/checkout@v3-  #     - uses: actions/setup-go@v3-  #       with:-  #         go-version: '1.21' # The Go version to download (if necessary) and use.-  #     - name: Build file-  #       run: GOOS=linux GOARCH=amd64 go build -o fog && zip fog.zip fog-  #     - name: Configure AWS Credentials-  #       uses: aws-actions/configure-aws-credentials@v2-  #       with:-  #         role-to-assume: arn:aws:iam::613864977396:role/github-oidc-FogS3DeploymentsRole-EQO45UDOAHSL-  #         aws-region: us-east-1-  #     - name: Copy to S3 bucket-  #       run: |-  #         aws s3 cp fog.zip s3://public.ig.nore.me/fog/latest.zip-  #         aws s3 cp fog.zip s3://public.ig.nore.me/fog/${{ env.APP_VERSION }}.zip-  #         aws s3 cp fog.zip s3://public.ig.nore.me/fog/v${{ env.APP_VERSION }}.zip+  lambda-package:+    name: Package AL2023 Lambda+    runs-on: ubuntu-latest+    steps:+      - uses: actions/checkout@v7.0.1+      - uses: actions/setup-go@v7.0.0+        with:+          go-version-file: go.mod+      - uses: actions/setup-python@v7.0.0+        with:+          python-version: '3.14'+      - run: make package-lambda+      - run: python3 -m unittest discover -s test/lambda -v+      - name: Attach Lambda archive to release+        env:+          GH_TOKEN: ${{ secrets.GITHUB_TOKEN }}+          RELEASE_TAG: ${{ github.event.release.tag_name }}+        run: gh release upload "$RELEASE_TAG" dist/lambda.zip dist/lambda-x86_64.zip dist/lambda-arm64.zip --clobber
Makefile Modified
diff --git a/Makefile b/Makefileindex 6154b44..621bae3 100644--- a/Makefile+++ b/Makefile@@ -172,3 +172,10 @@ help: 	test-integration-verbose test-all test-coverage test-golden test-golden-update \ 	test-golden-verbose test-golden-check fmt vet lint modernize check clean install \ 	deps-tidy deps-update security-scan go-functions update-v1-tag help++# Package both deployed report architectures for provided.al2023.+.PHONY: package-lambda+package-lambda:+	./scripts/package-lambda.sh dist/lambda-x86_64.zip x86_64+	./scripts/package-lambda.sh dist/lambda-arm64.zip arm64+	cp dist/lambda-x86_64.zip dist/lambda.zip
examples/templates/fogreport-builder.yaml Modified
diff --git a/examples/templates/fogreport-builder.yaml b/examples/templates/fogreport-builder.yamlindex 491efeb..e68a961 100644--- a/examples/templates/fogreport-builder.yaml+++ b/examples/templates/fogreport-builder.yaml@@ -158,7 +158,7 @@ Resources:               )        Handler: index.lambda_handler-      Runtime: python3.9+      Runtime: python3.14       Architectures:         - x86_64       Policies:
examples/templates/fogreport-lambda.yaml Modified
diff --git a/examples/templates/fogreport-lambda.yaml b/examples/templates/fogreport-lambda.yamlindex 9182800..1eea567 100644--- a/examples/templates/fogreport-lambda.yaml+++ b/examples/templates/fogreport-lambda.yaml@@ -7,6 +7,12 @@ Globals:   Function:     Timeout: 10 Parameters:+  LambdaArchitecture:+    Type: String+    Description: Preserve the existing function architecture when upgrading (x86_64 or arm64).+    AllowedValues:+    - x86_64+    - arm64   ReportS3Bucket:     Type: String     Description: Name of the bucket the reports should be send to. If empty, a new@@ -38,11 +44,11 @@ Resources:     Properties:       CodeUri:         Bucket: public.ig.nore.me-        Key: !Sub "fog/${FogVersion}.zip"-      Handler: fog-      Runtime: go1.x+        Key: !Sub "fog/al2023/${LambdaArchitecture}/${FogVersion}.zip"+      Handler: bootstrap+      Runtime: provided.al2023       Architectures:-      - x86_64+      - !Ref LambdaArchitecture       Environment:         Variables:           ReportS3Bucket:
go.mod Modified
diff --git a/go.mod b/go.modindex efdc348..c965cd6 100644--- a/go.mod+++ b/go.mod@@ -1,6 +1,6 @@ module github.com/ArjenSchwarz/fog -go 1.25.3+go 1.27.2  require ( 	github.com/aws/aws-sdk-go-v2 v1.39.3@@ -43,7 +43,7 @@ require (  require ( 	github.com/ArjenSchwarz/go-output/v2 v2.6.0-	github.com/aws/aws-lambda-go v1.50.0+	github.com/aws/aws-lambda-go v1.55.1 	github.com/aws/aws-sdk-go-v2/service/ec2 v1.254.1 	github.com/aws/aws-sdk-go-v2/service/organizations v1.45.3 	github.com/aws/aws-sdk-go-v2/service/ssoadmin v1.36.2
main.go Modified
diff --git a/main.go b/main.goindex b3c0fbf..e05cb6e 100644--- a/main.go+++ b/main.go@@ -38,6 +38,7 @@ import ( 	"os" 	"strings" 	"time"+	_ "time/tzdata" // Preserve named report timezones in minimal Lambda environments.  	"github.com/ArjenSchwarz/fog/cmd" 	"github.com/aws/aws-lambda-go/lambda"
main_test.go Modified
diff --git a/main_test.go b/main_test.goindex 6c748d8..704c797 100644--- a/main_test.go+++ b/main_test.go@@ -138,3 +138,33 @@ func TestHandleRequestPassesTrimmedStackIDToReportGeneration(t *testing.T) { 		t.Fatalf("expected trimmed stack-id to be forwarded, got %q", receivedStackID) 	} }++// TestHandleRequestPreservesReportContract covers settings and error forwarding+// when the same handler is entered through the AL2023 Runtime API client.+func TestHandleRequestPreservesReportContract(t *testing.T) {+	t.Setenv("ReportS3Bucket", "reports-bucket")+	t.Setenv("ReportOutputFormat", "html")+	t.Setenv("ReportNamePattern", "reports/$STACKNAME.html")+	t.Setenv("ReportTimezone", "Australia/Melbourne")+	original := generateReportFromLambda+	t.Cleanup(func() { generateReportFromLambda = original })+	failure := errors.New("report upload failed")+	for _, result := range []error{nil, failure} {+		called := false+		generateReportFromLambda = func(stack, bucket, filename, format, timezone string) error {+			called = true+			if stack != "stack-id" || bucket != "reports-bucket" || filename != "reports/$STACKNAME.html" || format != "html" || timezone != "Australia/Melbourne" {+				t.Fatalf("report settings changed: %q %q %q %q %q", stack, bucket, filename, format, timezone)+			}+			return result+		}+		message := EventBridgeMessage{}+		message.Detail.StackId = "stack-id"+		if err := HandleRequest(message); !errors.Is(err, result) {+			t.Fatalf("expected report result %v, got %v", result, err)+		}+		if !called {+			t.Fatal("report generator was not called")+		}+	}+}
scripts/package-lambda.sh Added
diff --git a/scripts/package-lambda.sh b/scripts/package-lambda.shnew file mode 100755index 0000000..4655def--- /dev/null+++ b/scripts/package-lambda.sh@@ -0,0 +1,21 @@+#!/usr/bin/env bash+# Build an AL2023 Lambda archive without depending on the host libc.+set -euo pipefail+repo_root="$(cd "$(dirname "${BASH_SOURCE[0]}")/.." && pwd)"+output="${1:-$repo_root/dist/lambda.zip}"+architecture="${2:-x86_64}"+case "$architecture" in+  x86_64) go_arch=amd64 ;;+  arm64) go_arch=arm64 ;;+  *) echo "Unsupported Lambda architecture: $architecture (expected x86_64 or arm64)" >&2; exit 2 ;;+esac+mkdir -p "$(dirname "$output")"+output="$(cd "$(dirname "$output")" && pwd)/$(basename "$output")"+build_dir="$(mktemp -d)"+trap 'rm -rf "$build_dir"' EXIT+cd "$repo_root"+CGO_ENABLED=0 GOOS=linux GOARCH="$go_arch" go build -trimpath -tags lambda.norpc -ldflags "-s -w" -o "$build_dir/bootstrap" .+chmod 755 "$build_dir/bootstrap"+# Always create a fresh archive: zip otherwise retains obsolete entries.+(cd "$build_dir" && zip -q -X lambda.zip bootstrap)+mv "$build_dir/lambda.zip" "$output"
test/lambda/test_package.py Added
diff --git a/test/lambda/test_package.py b/test/lambda/test_package.pynew file mode 100644index 0000000..f3fe15e--- /dev/null+++ b/test/lambda/test_package.py@@ -0,0 +1,142 @@+"""Exercise the actual deployment archive and inline trigger without AWS access."""+import http.server+import json+import os+from pathlib import Path+import platform+import queue+import stat+import struct+import subprocess+import sys+import tempfile+import textwrap+import threading+import types+import unittest+from unittest.mock import Mock, patch+import zipfile++ROOT = Path(__file__).resolve().parents[2]+++class LambdaPackageTests(unittest.TestCase):+    def test_archives_are_executable_static_linux_with_matching_architectures(self):+        for architecture, machine in [('x86_64', 62), ('arm64', 183)]:+            with self.subTest(architecture=architecture):+                with zipfile.ZipFile(ROOT / f'dist/lambda-{architecture}.zip') as archive:+                    self.assertEqual(archive.namelist(), ['bootstrap'])+                    info = archive.getinfo('bootstrap')+                    self.assertTrue((info.external_attr >> 16) & stat.S_IXUSR)+                    data = archive.read('bootstrap')+                self.assertEqual(data[:6], b'\x7fELF\x02\x01')+                self.assertEqual(struct.unpack_from('<H', data, 18)[0], machine)+                # A CGO-free executable must have no dynamic interpreter (PT_INTERP).+                offset = struct.unpack_from('<Q', data, 32)[0]+                size, count = struct.unpack_from('<HH', data, 54)+                self.assertNotIn(3, [struct.unpack_from('<I', data, offset + i * size)[0]+                                     for i in range(count)])++    def test_unqualified_archive_preserves_x86_64_alias(self):+        self.assertEqual((ROOT / 'dist/lambda.zip').read_bytes(),+                         (ROOT / 'dist/lambda-x86_64.zip').read_bytes())++    def test_invalid_architecture_is_rejected_before_creating_output(self):+        with tempfile.TemporaryDirectory() as temp:+            output = Path(temp) / 'invalid.zip'+            result = subprocess.run([str(ROOT / 'scripts/package-lambda.sh'), str(output), 'invalid'],+                                    capture_output=True, text=True, check=False)+            self.assertEqual(result.returncode, 2)+            self.assertIn('Unsupported Lambda architecture', result.stderr)+            self.assertFalse(output.exists())++    def test_bootstrap_reports_handler_errors_through_runtime_api(self):+        received = queue.Queue()++        class Runtime(http.server.BaseHTTPRequestHandler):+            def log_message(self, *args):+                pass++            def do_GET(self):+                self.send_response(200)+                self.send_header('Lambda-Runtime-Aws-Request-Id', 'smoke-request')+                self.send_header('Lambda-Runtime-Deadline-Ms', '4102444800000')+                self.end_headers()+                self.wfile.write(b'{"detail":{"stack-id":"test"}}')++            def do_POST(self):+                # aws-lambda-go streams error payloads with chunked encoding.+                if self.headers.get('Transfer-Encoding') == 'chunked':+                    chunks = []+                    while True:+                        size = int(self.rfile.readline().split(b';', 1)[0], 16)+                        if size == 0:+                            while self.rfile.readline().strip():+                                pass  # Consume optional trailers through the empty line.+                            break+                        chunks.append(self.rfile.read(size))+                        self.rfile.read(2)+                    body = b''.join(chunks)+                else:+                    body = self.rfile.read(int(self.headers['Content-Length']))+                received.put((self.path, json.loads(body)))+                self.send_response(202)+                self.end_headers()++        with tempfile.TemporaryDirectory() as temp:+            binary = Path(temp) / 'bootstrap'+            architecture = {'x86_64': 'x86_64', 'AMD64': 'x86_64',+                            'aarch64': 'arm64', 'arm64': 'arm64'}.get(platform.machine())+            if platform.system() == 'Linux' and architecture:+                with zipfile.ZipFile(ROOT / f'dist/lambda-{architecture}.zip') as archive:+                    binary.write_bytes(archive.read('bootstrap'))+                binary.chmod(0o755)+            else:+                # macOS cannot execute the Linux archive. CI runs the exact archive.+                subprocess.run(['go', 'build', '-tags', 'lambda.norpc', '-o', str(binary), '.'],+                               cwd=ROOT, check=True)+            with http.server.ThreadingHTTPServer(('127.0.0.1', 0), Runtime) as server:+                thread = threading.Thread(target=server.serve_forever, daemon=True)+                thread.start()+                env = os.environ.copy()+                for key in ('ReportS3Bucket', 'ReportOutputFormat'):+                    env.pop(key, None)+                env.update(AWS_LAMBDA_FUNCTION_NAME='fog-smoke',+                           AWS_LAMBDA_RUNTIME_API=f'127.0.0.1:{server.server_port}')+                with open(os.devnull, 'w') as output:+                    process = subprocess.Popen([str(binary)], env=env, stdout=output, stderr=output)+                    try:+                        path, body = received.get(timeout=20)+                        self.assertEqual(path, '/2018-06-01/runtime/invocation/smoke-request/error')+                        self.assertIn('ReportS3Bucket is not set', body['errorMessage'])+                    finally:+                        process.terminate()+                        process.wait(timeout=5)+                        server.shutdown()+                thread.join(timeout=5)+++class InlineTriggerTests(unittest.TestCase):+    def setUp(self):+        template = (ROOT / 'examples/templates/fogreport-builder.yaml').read_text()+        source = textwrap.dedent(template.split('Fn::Sub: |\n', 1)[1].split('\n      Handler:', 1)[0])+        source = source.replace('${AmplifyApp.AppId}', 'test-app')+        self.client = Mock()+        module = types.ModuleType('boto3')+        module.client = Mock(return_value=self.client)+        self.module = module+        self.namespace = {}+        with patch.dict(sys.modules, boto3=module):+            exec(compile(source, 'inline-trigger', 'exec'), self.namespace)++    def test_requests_main_release(self):+        self.namespace['lambda_handler']({'Records': []}, None)+        self.module.client.assert_called_once_with('amplify')+        self.client.start_job.assert_called_once_with(appId='test-app', branchName='main', jobType='RELEASE')++    def test_service_failure_propagates(self):+        failure = RuntimeError('Amplify unavailable')+        self.client.start_job.side_effect = failure+        with self.assertRaises(RuntimeError) as caught:+            self.namespace['lambda_handler']({}, None)+        self.assertIs(caught.exception, failure)

Docs (7)

CHANGELOG.md Modified
diff --git a/CHANGELOG.md b/CHANGELOG.mdindex 440c7f9..f70c545 100644--- a/CHANGELOG.md+++ b/CHANGELOG.md@@ -1,6 +1,9 @@ Unreleased ========== +### Changed+- Report Lambda templates now use Amazon Linux 2023 and Python 3.14, with x86_64/ARM64 bootstrap packaging, explicit architecture selection, current Go/runtime client and main-only CI publication alongside GitHub artifacts; see docs/lambda-runtime-upgrade.md before deployment.+ ### Fixed - Fixed `fog deploy` panicking when `CreateChangeSet` returns no changeset ID; it now returns a descriptive error through the normal deploy error path - Fixed panics when AWS returns a partial or empty `DescribeChangeSet` response while parsing changesets (`AddChangeset`); the response is now validated before use
README.md Modified
diff --git a/README.md b/README.mdindex bdf91bf..e9c8cd0 100644--- a/README.md+++ b/README.md@@ -15,6 +15,8 @@ Fog is a tool to manage your CloudFormation deployments and ensure you have all - **[Advanced Usage](docs/user-guide/advanced-usage.md)** - Complex scenarios and CI/CD integration - **[Troubleshooting Guide](docs/user-guide/troubleshooting.md)** - Solutions to common problems +- **[Report Lambda runtime migration](docs/lambda-runtime-upgrade.md)** - Bootstrap packaging, supported runtimes and deployment prerequisites+ ### Diagrams  - [Architecture Overview](docs/architecture-overview.drawio.svg) - System architecture
docs/lambda-runtime-upgrade.md Added
diff --git a/docs/lambda-runtime-upgrade.md b/docs/lambda-runtime-upgrade.mdnew file mode 100644index 0000000..a438166--- /dev/null+++ b/docs/lambda-runtime-upgrade.md@@ -0,0 +1,122 @@+# Fog report Lambda runtime migration++The report template now uses `provided.al2023`; the inline Amplify trigger uses+`python3.14`. Go builds use 1.27.2 and `aws-lambda-go` v1.55.1. Architecture stays+the existing x86_64 and arm64 deployments. Report events, environment variables and generated output are unchanged.++## Official version evidence++Checked 16 October 2026 UTC:++- [AWS runtime table](https://docs.aws.amazon.com/lambda/latest/dg/lambda-runtimes.html):+  `provided.al2023` and Python 3.14 are supported; Python 3.15 is explicitly preview.+  Python 3.9, go1.x and provided.al2 are deprecated.+- [AWS Go packaging](https://docs.aws.amazon.com/lambda/latest/dg/golang-package.html):+  executable `bootstrap` at ZIP root, matching architecture, optional `lambda.norpc`,+  and `CGO_ENABLED=0` to avoid host libc dependencies.+- [Go release metadata](https://go.dev/dl/?mode=json) reports `go1.27.2`, stable true.+- [Official Lambda Go releases](https://github.com/aws/aws-lambda-go/releases) and+  [module metadata](https://proxy.golang.org/github.com/aws/aws-lambda-go/@latest)+  report v1.55.1. Other AWS SDK/CLI dependencies were not broadly refreshed.+- [Python release lifecycle](https://devguide.python.org/versions/) supplies language+  support context. Lambda controls the managed runtime's Python patch version.+  AWS permits runtime-provided boto3 for inline CloudFormation code; this trigger+  has no separately packaged Python dependency tree.+- Workflow action versions were checked against their official GitHub latest-release+  pages: checkout v7.0.1, setup-go v7.0.0, setup-python v7.0.0,+  upload-artifact v7.0.2, golangci-lint-action v9.3.0, go-release-action v1.55, configure-aws-credentials v6.3.0. The linter is pinned to v2.14.0, built locally with Go 1.27.2.+  Hosted `ubuntu-latest` selects GitHub's maintained stable runner image.++## Build and validate locally++```sh+make package-lambda+python3 -m unittest discover -s test/lambda -v+go test ./... -v+```++`make package-lambda` builds `dist/lambda-x86_64.zip` and `dist/lambda-arm64.zip`.+Each ZIP contains only an executable Linux `bootstrap` for its named architecture.+`dist/lambda.zip` remains an exact copy of the x86_64 package for compatibility.+The script also accepts an output path and explicit AWS architecture:++```sh+./scripts/package-lambda.sh dist/custom-arm64.zip arm64+```++Invalid architectures are rejected before creating an output. Both builds disable+CGO and legacy RPC support, and embed timezone data. Tests inspect ZIP layout,+executable mode, ELF machine type (x86-64 or AArch64) and absence of a dynamic+interpreter. On Linux, the smoke test executes the matching extracted ZIP. GitHub+runs it on x86_64 and `ubuntu-24.04-arm`, using the same uploaded packages. The ARM+job downloads the archives; it does not rebuild them. On macOS, static checks cover+both ZIPs and a native equivalent exercises the Runtime API without AWS calls.++Push/PR CI saves all three ZIPs in `fog-lambda-al2023-{commit}`. Releases attach the+same filenames beside CLI binaries. Main-only OIDC/S3 publishing waits for both+architecture checks. It retains `fog/unstable.zip` with the legacy root `fog`+executable, and the unqualified AL2023 x86_64 alias `fog/al2023/unstable.zip`.+Architecture-specific bootstrap packages publish to:++- `fog/al2023/x86_64/unstable.zip`+- `fog/al2023/arm64/unstable.zip`++Feature pushes and all PR events skip the entire publishing job. Its existing role+and permission levels are unchanged; no AWS policy updates are made. The release+S3 publisher was already disabled and remains so. The GitHub ARM runner and current+download-artifact action were verified against [GitHub runner documentation](https://docs.github.com/en/actions/reference/runners/github-hosted-runners)+and the [official v8.0.2 release](https://github.com/actions/download-artifact/releases/tag/v8.0.2).++## Deployment prerequisites — separate authorization required++1. **Set `LambdaArchitecture` explicitly to the function's current architecture.**+   The template has no default, so adding this parameter cannot silently change an+   ARM64 function to x86_64. The PT report stacks use `x86_64`; the Demo 2023 report+   stack uses `arm64`. This parameter selects both the Lambda architecture and the+   matching S3 key `fog/al2023/${LambdaArchitecture}/${FogVersion}.zip`.+2. For a release tag, obtain the matching `lambda-{architecture}.zip` and publish it+   separately to `fog/al2023/{architecture}/{release-tag}.zip`; use that exact tag as+   `FogVersion`. The default `latest` requires a separately published alias under+   the selected architecture. Main-only publishing supplies `unstable` after an+   authorized merge/main push. No objects were published during this work.+3. Verify bucket region/availability and existing publisher permission for the new+   keys before merge. No IAM changes are made. Do not use the x86_64 alias for ARM64.+4. Review each owning stack's actual template and source artifact before updating+   runtime and code together. Preserve deployed parameters, architecture, triggers+   and policies. Existing runtime/architecture/handler and stack ownership are+   inventoried below; exact deployed template, S3 keys and source equivalence remain+   unverified because `GetTemplate` and `GetFunctionConfiguration` are denied.+5. Validate report generation and Amplify rebuilds only in a separately authorized+   deployment. Plan rollback with a previous compatible bootstrap artifact;+   deprecated runtime rollback may be blocked. Use versioned artifact keys because+   changing bytes behind a fixed key alone is not a CloudFormation code update.++## Deployed-source coverage++The renewed-session read-only check on 17 October independently confirmed all five+stack/logical-resource/function relationships with `ListStackResources`. Permitted+`ListFunctions` reads confirmed the runtime, architecture and handler. Authentication+works, but the current ViewOnlyAccess roles deny `GetTemplate` and+`GetFunctionConfiguration`; no denied operation was retried or circumvented. No code+archives were downloaded. Source-to-stack ownership is confirmed; exact deployed+source/template matching is not.++| Audit target | Runtime / architecture / handler | Source coverage |+|---|---|---|+| PT 2022 report generator, Sydney | go1.x / x86_64 / fog | Confirmed fogreport-lambda / ReportGeneratorFunction ownership matches maintained template. New x86_64 bootstrap supported; exact deployed template/code key unreadable. |+| PT 2022 report generator, Virginia | go1.x / x86_64 / fog | Same confirmed ownership and supported x86_64 migration. |+| Demo 2023 report generator, Virginia | provided.al2 / arm64 / bootstrap | Confirmed same stack/logical ID. Select LambdaArchitecture=arm64 and the ARM64 ZIP; exact deployed definition/source remains unreadable. |+| Demo 2023 builder trigger, Virginia | python3.9 / x86_64 / index.lambda_handler | Confirmed fogreport-builder / TriggerFunction ownership matches maintained inline-handler definition. Python 3.14 target; inline-source equivalence unverified. |+| Fog Report legacy build trigger, Sydney | python3.9 / x86_64 / app.lambda_handler | Separate fog-reports-trigger-build / HelloWorldFunction stack. Description confirms an Amplify build job; no confirmed source found. Remains outside PR coverage. |++The adjacent `fogreport-generator` repository is an older CDK/site prototype, not+Fog's runtime entry point. Its tracked Go source has no Lambda runtime definition;+a locally untracked `fullstack.yaml` defines site infrastructure without this trigger.+Its modified go.mod and untracked fullstack.yaml/go.sum were preserved. Historical+site report files mention the legacy stack but do not establish maintained ownership.+Other workshop HelloWorld SAM functions found locally do not prove this stack's source.+Do not deploy a guessed template over the legacy stack.++The supplied audit also records EventBridge DescribeRule and S3 notification read+denials. Trigger permissions/targets do not prove current enabled state or activity.+A future deployment must resolve those checks with existing authorized access.
specs/lambda-runtime-upgrade/decision_log.md Added
diff --git a/specs/lambda-runtime-upgrade/decision_log.md b/specs/lambda-runtime-upgrade/decision_log.mdnew file mode 100644index 0000000..82fd0ed--- /dev/null+++ b/specs/lambda-runtime-upgrade/decision_log.md@@ -0,0 +1,46 @@+# Decision log++| ID | Decision | Rationale |+|---|---|---|+| D1 | Maintenance smolspec; proceed under delegated implementation authorization | No product behavior changes, schema/auth changes or contested architecture. Source changes are reversible; AWS deployment is excluded. User authorized feature isolation and implementation. |+| D2 | provided.al2023 and Python 3.14 | AWS supported runtime table lists AL2023 and explicitly marks Python 3.15 preview (checked 2026-10-16 UTC). |+| D3 | Go 1.27.2; Lambda Go v1.55.1 | Official go.dev release JSON marks 1.27.2 stable; official module metadata reports v1.55.1. No guessed versions. |+| D4 | Separate fog/al2023 artifact prefix | Existing public fog/{version}.zip archives contain fog, so selecting that key under the new runtime would fail. Preserve legacy consumers instead of overwriting their archive format. |+| D5 | Preserve inline Python SDK | AWS explicitly supports runtime-provided SDK for inline CloudFormation code; packaging a separate Python artifact is unnecessary here. |+| D6 | Independent clone and feature branch | Original Fog checkout contains unrelated edits; original fogreport-generator has modified go.mod and untracked fullstack.yaml/go.sum. No source working changes copied. |++Transit: initialization at http://localhost:3141/mcp timed out after eight seconds with network access. No creation request sent, no ticket exists from this attempt. Requested ticket: Fog — Upgrade report Lambda runtimes and packaging; project explicitly Fog; type chore. Do not repeatedly block independent work on Transit.++| D7 | Remove CI AWS publication | Explicit no AWS changes boundary: feature pushes and releases only produce GitHub artifacts. Existing every-push publication was unsafe for this authorized task. Future S3 publication requires separate authorization. |+| D8 | Embed timezone database | A statically linked binary can still depend on OS timezone files; embedding preserves named timezones in minimal Lambda hosts. |++Explanation validation classified the publication wording as a scope ambiguity; the explicit no-AWS-writes authorization settles it by removing publication. Other findings were documentation/acceptance gaps, resolved with source URLs, audit target guide, artifact alias mapping, timezone embedding, contract tests and Linux/native smoke-test distinctions. Design critique confirms runtime+archive updates must travel together; no alternative architecture or product behavior decision remains.++Design critique: use a new versioned object key before stack migration; fixed-key S3 overwrites are not CloudFormation code updates. CI performs no AWS writes. Runtime API smoke exercises initialization and error reporting; successful report behavior uses the existing injected generator unit test to avoid AWS calls. Linux amd64 CI runs the exact archive, while macOS runs a native equivalent. Fresh AWS template identity remains unverified due to expired SSO. Exact account/function audit evidence stays outside this public branch.++Pre-push review: reuse, efficiency and spec agents found no issues. Quality review found the mock Runtime API incorrectly assumed Content-Length. Fixed chunked body/trailer decoding; Python 3.14 smoke rerun passed. No production-handler change was needed.++## Publication correction after parent review++D7 is superseded by D9; its original rationale is retained above as history, not as the final design. Removing valid publication capability was broader than necessary for a task that must not deploy. No runtime or security defect required deleting the publisher.++| ID | Decision | Rationale |+|---|---|---|+| D9 | Restore OIDC/S3 publisher with main-push-only guards | Preserve existing fog/unstable.zip publishing and legacy archive layout. Add a separate AL2023 unstable key for the new runtime; feature pushes and PRs skip every publishing step. No main merge or workflow dispatch is authorized or performed. Existing publisher IAM configuration is unchanged; new-prefix permission must be verified before merge. |++The release S3 block was already commented out before this branch, so no active release publishing capability was removed. Release-tag/latest publication remains an operator prerequisite. Exact-head CI on d135972 is inspected separately; the existing Claude review exits is_error:true after one turn, zero cost, empty model usage and zero permission denials, with detailed SDK error output hidden by the action. Logs do not establish authentication or quota as its cause. No review finding was emitted.++Correction verification: independent quality/spec reviews found no findings. actionlint exposed the existing unquoted release version extraction; replaced it with quoted GITHUB_REF_NAME/GITHUB_ENV expansion. Legacy Linux amd64 build succeeds without lambda.norpc, preserving the Go1.x RPC entry point. The prior d135972 exact-head build-and-test run passed; restored publisher is not eligible on this feature branch. No AWS call was made.++## ARM64 coverage correction++| ID | Decision | Rationale |+|---|---|---|+| D10 | Preserve both inventoried architectures with required LambdaArchitecture and qualified keys | Renewed-session ListFunctions proves the Demo report is arm64 while both PT reports are x86_64. Build both bootstraps; bind the architecture and artifact key to one required parameter with no default, preventing a silent architecture migration. This corrects the original x86_64 assumption without changing report behavior or selecting a new architecture for any stack. |+| D11 | Execute the same uploaded ARM64 archive on a native GitHub ARM runner before main-only publication | Static ELF checks catch a wrong build target; a native Runtime API smoke verifies actual initialization. ARM job downloads existing build artifacts rather than recompiling. Publisher retains the existing role/permission levels and main-only guard and waits for both validations. Unqualified x86_64 archive/key aliases remain compatible. |++AWS evidence is limited to permitted metadata: stack/logical-resource ownership and runtime/architecture/handler confirmed for five functions. GetTemplate/GetFunctionConfiguration were denied, so exact source/template equivalence is unverified. No alternate access path was sought for denied contents. The separate legacy HelloWorldFunction uses app.lambda_handler; source remains missing and no code is guessed for it. No AWS operations are performed for this packaging correction.++ARM64 local verification: both architecture packages build successfully; six Python 3.14 archive/alias/invalid-input/Runtime API/trigger tests pass; actionlint and cfn-lint pass with only previously recorded W1031/W3045 exclusions. Reuse, quality, efficiency and spec reviewers report no findings. Native Linux ARM64 acceptance awaits exact-head CI; task 4 stays open until that result is verified.++Native validation accepted: exact implementation head 6bcf488 passes x86_64 build/tests/lint and the native ARM64 smoke of the downloaded ZIP (PR workflow run 39033796920). The main-only publish job was skipped. Task 4 is complete. No AWS operation or permission change was made.
specs/lambda-runtime-upgrade/implementation.md Added
diff --git a/specs/lambda-runtime-upgrade/implementation.md b/specs/lambda-runtime-upgrade/implementation.mdnew file mode 100644index 0000000..cd170b6--- /dev/null+++ b/specs/lambda-runtime-upgrade/implementation.md@@ -0,0 +1,44 @@+# Implementation explanation++## Beginner++Fog's report generator needs a current AWS environment and a correctly named start+program. The ZIP now contains that start program, and the site rebuild trigger uses+a supported Python version. Reports keep their existing inputs and output formats.++## Intermediate++The SAM report template pairs provided.al2023 with a root bootstrap built for Linux+amd64 and arm64 without CGO. The existing main function enters aws-lambda-go's Runtime API+loop; no separate report implementation was introduced. Timezone data is embedded.+The inline trigger stays an Amplify main-branch RELEASE request. CI saves GitHub+artifacts for validation. Main-only pushes preserve OIDC/S3 publication of both the+legacy fog archive and the separately named AL2023 bootstrap archives. Feature pushes+and PR events skip credentials and S3 publication.++## Expert++Runtime, architecture, executable mode and S3 key must be migrated as one compatible+unit. The separate al2023 prefix avoids replacing legacy fog executables. The static+ELF check excludes a libc interpreter; Linux x86_64 and ARM64 CI execute the matching extracted+ZIP, while macOS validates that archive and runs a host-native equivalent. The fake+Runtime API must decode chunked request bodies and trailers used by aws-lambda-go.+Handler unit tests check settings, success and error forwarding; smoke validation+checks the Runtime API error path without AWS network calls. Full end-to-end report+and Amplify execution still require separately authorized deployed validation.++## Completeness assessment++Maintained Fog templates, library/toolchain, archive builder, CI and contract tests+are implemented. No AWS function has been upgraded by these source changes. Current+SSO works, but template/configuration reads are denied, so exact source/template+matching remains unverified; the separate legacy+HelloWorldFunction source was not found. Compatible S3 artifacts must be published+under separate authorization before updating any stack. Transit ticket creation is+blocked before request submission by a local MCP initialization timeout.++The required LambdaArchitecture parameter selects both the function architecture+and its architecture-qualified artifact key; no default silently migrates existing+ARM64 deployments. Both ZIPs are built once, checked for correct ELF targets, then+executed on matching Linux GitHub runners. Main-only publication waits for both jobs+and retains legacy and unqualified x86_64 aliases.
specs/lambda-runtime-upgrade/smolspec.md Added
diff --git a/specs/lambda-runtime-upgrade/smolspec.md b/specs/lambda-runtime-upgrade/smolspec.mdnew file mode 100644index 0000000..d093b64--- /dev/null+++ b/specs/lambda-runtime-upgrade/smolspec.md@@ -0,0 +1,32 @@+# Lambda runtime upgrade++## Overview+Fog report functions use deprecated Go and Python Lambda runtimes. Update maintained templates, runtime library, toolchain and packaging while preserving report behavior and both deployed architectures (x86_64 and arm64).++## Requirements+- Maintained report templates MUST select generally available supported Lambda runtimes, verified against official documentation.+- The Go deployment archive MUST contain an executable Linux bootstrap matching the selected architecture at its root and run the existing report handler through the Lambda Runtime API.+- The Python trigger MUST request the same Amplify main branch RELEASE job and propagate service failures.+- Feature branch and pull request validation MUST NOT publish to AWS.+- Changes MUST preserve report event, environment and output contracts; no AWS deployment, IAM changes, deletion or merge is in scope.++## Implementation Approach+- Update examples/templates/fogreport-lambda.yaml to provided.al2023 and bootstrap; require explicit LambdaArchitecture (x86_64 or arm64) with no default, and use fog/al2023/{LambdaArchitecture}/{FogVersion}.zip so old go1.x archive keys remain separate.+- Update examples/templates/fogreport-builder.yaml to python3.14, preserving inline boto3 usage supported by AWS for inline templates.+- Update go.mod/go.sum to official stable Go 1.27.2 and aws-lambda-go v1.55.1. Other SDK modules remain unless compatibility requires changes.+- Add scripts/package-lambda.sh and a Makefile target using CGO_ENABLED=0, linux/amd64 or linux/arm64 and lambda.norpc. Reuse main.go handler selection and existing handler tests.+- Update .github/workflows/push.yml and release.yaml to use the module toolchain and package bootstrap; validate with PRs and publish build artifacts to GitHub. Preserve existing OIDC/S3 publication only for main pushes, retain the legacy fog archive at fog/unstable.zip, and publish architecture-specific bootstraps at fog/al2023/{architecture}/unstable.zip while retaining the unqualified AL2023 x86_64 alias. The publisher waits for x86_64 and native ARM64 smoke checks. Feature/PR events skip all publisher steps.+- Add executable archive/Runtime API smoke tests and inline Python success/failure tests; document migration in docs/lambda-runtime-upgrade.md and README.md.+- Audit the five known deployed functions through bounded metadata reads; document external legacy sources without editing their unrelated working changes.+- Dependencies: aws-lambda-go implements the Runtime API; inline Python uses runtime-provided boto3. Out of scope: wholesale SDK/CLI dependency refresh, Amplify/site redesign and external legacy repository changes.++Official sources checked 2026-10-16 UTC: https://docs.aws.amazon.com/lambda/latest/dg/lambda-runtimes.html ; https://docs.aws.amazon.com/lambda/latest/dg/golang-package.html ; https://go.dev/dl/?mode=json ; https://proxy.golang.org/github.com/aws/aws-lambda-go/@latest . Audit targets and limitations are recorded in docs/lambda-runtime-upgrade.md. Embed Go timezone data to retain named report timezones in minimal images. GitHub release lambda-{architecture}.zip maps to fog/al2023/{architecture}/{release-tag}.zip; lambda.zip remains an x86_64 copy; latest is a separately published alias. No templates are deployable until a compatible object is published.++## Risks and Assumptions+- Risk: changing runtime without changing the archive fails initialization. Mitigation: verify archive contents, executable mode, ELF architecture and a local Runtime API exchange using the extracted Linux archive on Linux x86_64 and arm64; on other hosts validate the archive and run a native binary using the same build tag. Verify a Runtime API error response without AWS calls, and handler success/error results with the existing report-generator test seam.+- Risk: AWS publication might run on feature pushes. Mitigation: guard legacy build, credential configuration and S3 writes with push plus refs/heads/main conditions.+- Prerequisite: separately authorize publication of the new artifact prefix and stack updates; existing hosted latest.zip is unsuitable for provided.al2023.+- Prerequisite: explicitly select the inventoried deployed architecture; the template has no architecture default. The 17 October inventory confirms x86_64 PT reports and the arm64 Demo report. Exact template/source matching remains unverified due to denied reads; legacy HelloWorld trigger source remains missing.++## Escalation Note+This change was scoped as a smolspec. If implementation reveals ambiguity only the user can resolve, an irreversible boundary (public API, persisted schema, auth path), or a contested architectural choice, stop and escalate to the full spec workflow rather than deciding it inline.
specs/lambda-runtime-upgrade/tasks.md Added
diff --git a/specs/lambda-runtime-upgrade/tasks.md b/specs/lambda-runtime-upgrade/tasks.mdnew file mode 100644index 0000000..92791b6--- /dev/null+++ b/specs/lambda-runtime-upgrade/tasks.md@@ -0,0 +1,16 @@+---+references:+    - specs/lambda-runtime-upgrade/smolspec.md+---+# Lambda runtime upgrade++- [x] 1. Supported report templates and Lambda library preserve report contracts, verified by handler and Python trigger tests <!-- id:zd468p1 -->++- [x] 2. Bootstrap archives initialize via the Runtime API and CI validates without feature-branch AWS publication <!-- id:zd468p2 -->+  - Blocked-by: zd468p1 (Supported report templates and Lambda library preserve report contracts, verified by handler and Python trigger tests)++- [x] 3. Upgrade builds and tests pass with migration prerequisites documented <!-- id:zd468p3 -->+  - Blocked-by: zd468p2 (Bootstrap archives initialize via the Runtime API and CI validates without feature-branch AWS publication)++- [x] 4. Both deployed architectures select matching bootstrap artifacts and pass native CI smoke checks <!-- id:zd468p4 -->+  - Blocked-by: zd468p2 (Bootstrap archives initialize via the Runtime API and CI validates without feature-branch AWS publication)

Other (2)

.gitignore Modified
diff --git a/.gitignore b/.gitignoreindex 921577b..0f5e08b 100644--- a/.gitignore+++ b/.gitignore@@ -18,4 +18,9 @@ fog rpdk.log  deployments.log-.claude/scripts\ No newline at end of file+.claude/scripts+# Generated Lambda build packages+/dist/++# Local Python test bytecode+__pycache__/
go.sum Modified
diff --git a/go.sum b/go.sumindex add64ab..1f6e226 100644--- a/go.sum+++ b/go.sum@@ -1,7 +1,7 @@ github.com/ArjenSchwarz/go-output/v2 v2.6.0 h1:7Ti94oTa9vOkgd91JZcMR8Bj/CDQG64nmKHn7qWaRYE= github.com/ArjenSchwarz/go-output/v2 v2.6.0/go.mod h1:6hL6FT0dlf8taBCy2fSqLJgBdFbiTMjT2FfFm6a6t1Y=-github.com/aws/aws-lambda-go v1.50.0 h1:0GzY18vT4EsCvIyk3kn3ZH5Jg30NRlgYaai1w0aGPMU=-github.com/aws/aws-lambda-go v1.50.0/go.mod h1:dpMpZgvWx5vuQJfBt0zqBha60q7Dd7RfgJv23DymV8A=+github.com/aws/aws-lambda-go v1.55.1 h1:We2cCp4BwqqH/JW+bEEo1FhgG71rslvjfi4y7KmlrR0=+github.com/aws/aws-lambda-go v1.55.1/go.mod h1:V+NzkHNR6vBC8C1PDloqSLE+7jYWFiPvJJFiCiTm8nE= github.com/aws/aws-sdk-go-v2 v1.39.3 h1:h7xSsanJ4EQJXG5iuW4UqgP7qBopLpj84mpkNx3wPjM= github.com/aws/aws-sdk-go-v2 v1.39.3/go.mod h1:yWSxrnioGUZ4WVv9TgMrNUeLV3PFESn/v+6T/Su8gnM= github.com/aws/aws-sdk-go-v2/aws/protocol/eventstream v1.7.2 h1:t9yYsydLYNBk9cJ73rgPhPWqOh/52fcWDQB5b1JsKSY=

Things to double-check

IAM/source access No denied AWS actions retried. New read policy was prepared for user application and uploaded separately; no AWS policy was applied.
Remote acceptance Exact-head native x86_64/ARM64 checks must complete before claiming both runtime smoke paths passed. No deployment or invocation is authorized.