From 674abdb8b947c86e51e369a27d9a68df1469f384 Mon Sep 17 00:00:00 2001 From: L Date: Wed, 4 Nov 2026 21:12:50 +1000 Subject: [PATCH 1/2] fix: publish successful environmental refreshes despite source outages --- .github/workflows/refresh-external.yml | 17 ++- .gitignore | 3 + AGENTS.md | 1 + package.json | 2 +- scripts/erddap.mjs | 4 +- scripts/external-refresh.mjs | 74 ++++++++++++ scripts/external-refresh.test.mjs | 151 +++++++++++++++++++++++++ scripts/fetch-external.mjs | 80 ++++++------- 8 files changed, 285 insertions(+), 47 deletions(-) create mode 100644 scripts/external-refresh.mjs create mode 100644 scripts/external-refresh.test.mjs diff --git a/.github/workflows/refresh-external.yml b/.github/workflows/refresh-external.yml index 4b7e45a..d8ed779 100644 --- a/.github/workflows/refresh-external.yml +++ b/.github/workflows/refresh-external.yml @@ -22,10 +22,11 @@ permissions: jobs: refresh: runs-on: ubuntu-latest - timeout-minutes: 30 + timeout-minutes: 60 outputs: version: ${{ steps.version.outputs.version }} changed: ${{ steps.diff.outputs.changed }} + fetch-outcome: ${{ steps.fetch.outcome }} steps: - uses: actions/checkout@v7 with: @@ -36,6 +37,8 @@ jobs: node-version: 26 - name: Fetch snapshots + id: fetch + continue-on-error: true run: node scripts/fetch-external.mjs - name: Detect changes @@ -81,3 +84,15 @@ jobs: packages: write with: ref: v${{ needs.refresh.outputs.version }} + + # Wait for the release/image before surfacing partial failure. Otherwise a failed + # refresh dependency would skip Docker and leave successful snapshots undeployed. + report: + needs: [refresh, docker] + if: always() && needs.refresh.outputs.fetch-outcome == 'failure' + runs-on: ubuntu-latest + steps: + - name: Report source failures + run: | + echo "::error::Some environmental sources failed. See the refresh job summary and fetch log. Successful snapshots were eligible for release; failed sources retained their previous snapshots." + exit 1 diff --git a/.gitignore b/.gitignore index 4dbf258..d46af96 100644 --- a/.gitignore +++ b/.gitignore @@ -44,3 +44,6 @@ vite.config.ts.timestamp-* # Local preview config /.claude/ + +# Incomplete environmental refresh staging (normally removed automatically) +.external-refresh-*/ diff --git a/AGENTS.md b/AGENTS.md index ac5a5dc..83ea921 100644 --- a/AGENTS.md +++ b/AGENTS.md @@ -170,6 +170,7 @@ Drop the workbook in `data/` named like `Physioshark_Shark Log 2026-2027.xlsx` ( - `docker-compose.yml` (local build) and `docker-compose.ghcr.yml` (published image). Both mount `${DATA_PATH:-./data}:/data:ro` and a `cache` volume at `/cache`. - `docker-release.yml`: builds linux/amd64 + arm64 and pushes on `v*` tag pushes, manual dispatch or `workflow_call`. Image name is lower-cased from the repo (`rummerlab/data-stats`). - `nightly-minor-deps-release.yml`: `npm-check-updates --target semver --cooldown 3`, full suite, then a patch release + image **only when a package that reaches the image moved** (tooling list in `scripts/nightlyRelease.mjs`; add new lint/test devDependencies there). It pushes to `main`, so branch protection needs a bypass for Actions. +- Environmental refresh (#159): `external-refresh.mjs` stages each source until it completes; a failed fetch retains its old files. HTTP 429 waits at least one minute and honors `Retry-After`; weather chunks pause 10 s. Historical ERDDAP 404s retry, final unpublished chunks do not. The workflow allows fetch failure through publishing, then a separate report job fails after Docker (even if Docker was skipped); source status is in the Actions summary. Do not fail the refresh job before publishing successful sources. - `refresh-external.yml`: weekly `fetch-external.mjs`; when `external/` changed it commits, tags a patch release and publishes the image. - Dependabot covers GitHub Actions only: its pnpm runs on Node < 26 and `engineStrict` fails every npm job. npm majors are upgraded by hand. - `ci.yml`: lint + check + unit tests, build + Playwright/axe, and a Docker build + smoke test (synthetic fixture) on both architectures. diff --git a/package.json b/package.json index 41a8a43..c679663 100644 --- a/package.json +++ b/package.json @@ -14,7 +14,7 @@ "preview": "vite preview", "prepare": "svelte-kit sync || echo ''", "check": "svelte-kit sync && svelte-check --tsconfig ./tsconfig.json", - "test": "node --test scripts/erddap.test.mjs && vitest run", + "test": "node --test scripts/erddap.test.mjs scripts/external-refresh.test.mjs && vitest run", "test:related": "vitest related --run", "test:watch": "vitest", "test:e2e": "playwright test", diff --git a/scripts/erddap.mjs b/scripts/erddap.mjs index 4b32f15..cbdb227 100644 --- a/scripts/erddap.mjs +++ b/scripts/erddap.mjs @@ -40,7 +40,9 @@ export async function readSeries({ `${v}%5B(${start}T12:00:00Z):1:(${final && latest ? 'last' : end + 'T12:00:00Z'})%5D${zlev ? '%5B(0.0)%5D' : ''}%5B(${lat})%5D%5B(${lon})%5D`; let text; try { - text = await get(`${base}/griddap/${dataset}.csv?${vars.map(select).join(',')}`); + text = await get(`${base}/griddap/${dataset}.csv?${vars.map(select).join(',')}`, { + retry404: !final || !latest + }); } catch (err) { // Only a final chunk with no published observations may be absent. Outages are fatal. if (!final || !String(err).includes('404')) throw err; diff --git a/scripts/external-refresh.mjs b/scripts/external-refresh.mjs new file mode 100644 index 0000000..1bb09b6 --- /dev/null +++ b/scripts/external-refresh.mjs @@ -0,0 +1,74 @@ +import { mkdtempSync, renameSync, rmSync, writeFileSync } from 'node:fs'; +import { dirname, join } from 'node:path'; + +export const sleep = (ms) => new Promise((resolve) => setTimeout(resolve, ms)); +export const WEATHER_CHUNK_DELAY_MS = 10_000; + +/** HTTP retries include body reads; injected I/O keeps outage tests fast and offline. */ +export function createGet({ + fetch: request = globalThis.fetch, + wait = sleep, + now = Date.now +} = {}) { + return async function get(url, { json = false, tries = 5, retry404 = false } = {}) { + let error; + for (let i = 0; i < tries; i++) { + let delay = 2000 * (i + 1) ** 2; + try { + const res = await request(url, { + signal: AbortSignal.timeout(120_000), + headers: { + 'user-agent': 'physioshark-data-stats (+https://github.com/RummerLab/data-stats)' + } + }); + if (res.ok) return await (json ? res.json() : res.text()); + error = new Error(`${res.status} ${url}`); + error.status = res.status; + if (res.status === 429) { + const value = res.headers.get('retry-after'); + const retryAfter = + value == null + ? 0 + : /^\d+(\.\d+)?$/.test(value.trim()) + ? Number(value) * 1000 + : Date.parse(value) - now(); + delay = Math.max(60_000 * (i + 1), Number.isFinite(retryAfter) ? retryAfter : 0); + } + await res.body?.cancel(); + if (res.status === 404 && !retry404) throw error; + } catch (err) { + error = err; + if (err.status === 404 && !retry404) throw err; + } + if (i + 1 < tries) { + console.warn(`[external] ${error.message}; retrying in ${delay / 1000}s`); + await wait(delay); + } + } + throw error; + }; +} + +/** Fetch into staging so a failed source never publishes its partially written files. */ +export async function refreshJobs(out, jobs, { report = console.log } = {}) { + const failed = []; + for (const [name, job] of Object.entries(jobs)) { + // Keep staging outside external/: interrupted runs must never git-add partial files. + const stage = mkdtempSync(join(dirname(out), '.external-refresh-')); + const files = new Set(); + try { + await job((file, body) => { + writeFileSync(join(stage, file), body); + files.add(file); + }); + for (const file of files) renameSync(join(stage, file), join(out, file)); + report(`[external] ${name}: refreshed (${files.size} files)`); + } catch (err) { + failed.push(name); + report(`[external] ${name}: FAILED — ${err.message ?? err}`); + } finally { + rmSync(stage, { recursive: true, force: true }); + } + } + return failed; +} diff --git a/scripts/external-refresh.test.mjs b/scripts/external-refresh.test.mjs new file mode 100644 index 0000000..f6465a2 --- /dev/null +++ b/scripts/external-refresh.test.mjs @@ -0,0 +1,151 @@ +import assert from 'node:assert/strict'; +import { mkdtempSync, readFileSync, readdirSync, rmSync, writeFileSync } from 'node:fs'; +import { tmpdir } from 'node:os'; +import { join } from 'node:path'; +import { test } from 'node:test'; +import { createGet, refreshJobs } from './external-refresh.mjs'; + +for (const [header, expected] of [ + [null, 60_000], + ['5', 60_000], + ['120', 120_000], + ['Wed, 04 Nov 2026 00:02:00 GMT', 120_000], + ['invalid', 60_000] +]) { + test(`429 recovers after Retry-After ${header}`, async () => { + const waits = []; + let calls = 0; + const get = createGet({ + now: () => Date.parse('2026-11-04T00:00:00Z'), + wait: async (ms) => waits.push(ms), + fetch: async () => + calls++ === 0 + ? new Response('', { status: 429, headers: header ? { 'Retry-After': header } : {} }) + : Response.json({ daily: { time: ['2026-11-01'] } }) + }); + assert.deepEqual(await get('https://example.test/weather', { json: true }), { + daily: { time: ['2026-11-01'] } + }); + assert.deepEqual(waits, [expected]); + assert.equal(calls, 2); + }); +} + +test('persistent 429 has bounded attempts and increasing backoff', async () => { + const waits = []; + let calls = 0; + const get = createGet({ + wait: async (ms) => waits.push(ms), + fetch: async () => { + calls++; + return new Response('', { status: 429 }); + } + }); + await assert.rejects(get('https://example.test/weather', { tries: 3 }), { status: 429 }); + assert.equal(calls, 3); + assert.deepEqual(waits, [60_000, 120_000]); +}); + +test('historical 404 retries, final 404 remains immediate', async () => { + let calls = 0; + const get = createGet({ + wait: async () => {}, + fetch: async () => (++calls % 2 ? new Response('', { status: 404 }) : new Response('recovered')) + }); + assert.equal(await get('https://example.test/history', { retry404: true }), 'recovered'); + assert.equal(calls, 2); + await assert.rejects(get('https://example.test/final'), { status: 404 }); + assert.equal(calls, 3); +}); + +test('failed response body reads retry within the attempt limit', async () => { + let calls = 0; + const get = createGet({ + wait: async () => {}, + fetch: async () => + ++calls === 1 + ? { + ok: true, + text: async () => { + throw new Error('body timeout'); + } + } + : new Response('complete') + }); + assert.equal(await get('https://example.test/body'), 'complete'); + assert.equal(calls, 2); +}); + +test('failed source retains all old files while other sources publish and report', async () => { + const out = mkdtempSync(join(tmpdir(), 'external-refresh-')); + const reports = []; + try { + writeFileSync(join(out, 'weather-daily.csv'), 'old daily'); + writeFileSync(join(out, 'weather-hourly.csv.gz'), 'old hourly'); + writeFileSync(join(out, 'climate.csv'), 'old climate'); + const failed = await refreshJobs( + out, + { + weather: async (write) => { + write('weather-daily.csv', 'new daily'); + write('weather-hourly.csv.gz', 'new hourly'); + throw new Error('source down'); + }, + climate: async (write) => write('climate.csv', 'new climate'), + tide: async (write) => write('tide.csv', 'new tide') + }, + { report: (line) => reports.push(line) } + ); + assert.deepEqual(failed, ['weather']); + assert.equal(readFileSync(join(out, 'weather-daily.csv'), 'utf8'), 'old daily'); + assert.equal(readFileSync(join(out, 'weather-hourly.csv.gz'), 'utf8'), 'old hourly'); + assert.equal(readFileSync(join(out, 'climate.csv'), 'utf8'), 'new climate'); + assert.equal(readFileSync(join(out, 'tide.csv'), 'utf8'), 'new tide'); + assert.ok(reports.some((line) => line.includes('weather: FAILED'))); + assert.deepEqual(readdirSync(out).sort(), [ + 'climate.csv', + 'tide.csv', + 'weather-daily.csv', + 'weather-hourly.csv.gz' + ]); + } finally { + rmSync(out, { recursive: true, force: true }); + } +}); + +test('CLI reports a failed weather source and publishes tide data with a failing exit status', async () => { + const { spawnSync } = await import('node:child_process'); + const { gunzipSync } = await import('node:zlib'); + const out = mkdtempSync(join(tmpdir(), 'external-cli-')); + try { + writeFileSync(join(out, 'weather-daily.csv'), 'old weather'); + const mock = `globalThis.fetch = async (url) => { + if (url.includes('archive-api.open-meteo.com')) return new Response('', { status: 404 }); + if (url.includes('/h015.csv')) return new Response('2026,11,1,12,1000'); + throw new Error('Unexpected request: ' + url); + };`; + const summary = join(out, 'summary.md'); + const result = spawnSync( + process.execPath, + [ + '--import', + `data:text/javascript,${encodeURIComponent(mock)}`, + 'scripts/fetch-external.mjs', + '--only=weather,tide' + ], + { encoding: 'utf8', env: { ...process.env, EXTERNAL_DIR: out, GITHUB_STEP_SUMMARY: summary } } + ); + assert.equal(result.status, 1, result.stderr); + assert.match(result.stdout, /weather: FAILED/); + assert.match(result.stdout, /tide: refreshed/); + assert.equal(readFileSync(join(out, 'weather-daily.csv'), 'utf8'), 'old weather'); + assert.match( + gunzipSync(readFileSync(join(out, 'tide-papeete-hourly.csv.gz'))).toString(), + /2026-11-01T02,1000/ + ); + assert.match(readFileSync(summary, 'utf8'), /weather: FAILED/); + assert.match(readFileSync(summary, 'utf8'), /tide: refreshed/); + } finally { + rmSync(out, { recursive: true, force: true }); + } +}); diff --git a/scripts/fetch-external.mjs b/scripts/fetch-external.mjs index 4c3ef7e..7430b87 100644 --- a/scripts/fetch-external.mjs +++ b/scripts/fetch-external.mjs @@ -22,11 +22,13 @@ * Output files are small CSVs (hourly series gzipped) committed to the repo, so the app and CI * never need network access. No spreadsheet data is read or sent anywhere. */ -import { mkdirSync, readFileSync, writeFileSync } from 'node:fs'; +import { appendFileSync, mkdirSync, readFileSync } from 'node:fs'; import { dirname, join } from 'node:path'; import { fileURLToPath } from 'node:url'; import { gzipSync } from 'node:zlib'; +import { createGet, refreshJobs, sleep, WEATHER_CHUNK_DELAY_MS } from './external-refresh.mjs'; + import { readSeries, validateDaily, chunks, OISST_MAX_LAG_DAYS } from './erddap.mjs'; const root = join(dirname(fileURLToPath(import.meta.url)), '..'); @@ -43,39 +45,19 @@ const want = (name) => only.length === 0 || only.includes(name); mkdirSync(OUT, { recursive: true }); -const sleep = (ms) => new Promise((r) => setTimeout(r, ms)); +const get = createGet(); +let writeSnapshot; const isoDay = (d) => d.toISOString().slice(0, 10); const daysAgo = (n) => isoDay(new Date(Date.now() - n * 86_400_000)); -async function get(url, { json = false, tries = 5 } = {}) { - for (let i = 0; i < tries; i++) { - try { - const res = await fetch(url, { - signal: AbortSignal.timeout(120_000), - headers: { - 'user-agent': 'physioshark-data-stats (+https://github.com/RummerLab/data-stats)' - } - }); - if (res.ok) return json ? res.json() : res.text(); - if (res.status === 404) throw new Error(`404 ${url}`); - console.warn(`[external] ${res.status} ${url}`); - } catch (err) { - if (String(err).includes('404')) throw err; - console.warn(`[external] ${err.message ?? err}`); - } - await sleep(2000 * (i + 1) ** 2); - } - throw new Error(`failed: ${url}`); -} - const fmt = (v, dp = 2) => v == null || Number.isNaN(v) ? '' : String(Math.round(v * 10 ** dp) / 10 ** dp); function writeCsv(name, header, rows, gzip = false) { const body = [header.join(','), ...rows.map((r) => r.join(','))].join('\n') + '\n'; - const path = join(OUT, gzip ? `${name}.gz` : name); - writeFileSync(path, gzip ? gzipSync(body, { level: 9 }) : body); - console.log(`[external] wrote ${path} (${rows.length} rows)`); + const file = gzip ? `${name}.gz` : name; + writeSnapshot(file, gzip ? gzipSync(body, { level: 9 }) : body); + console.log(`[external] staged ${file} (${rows.length} rows)`); } async function weather() { @@ -122,7 +104,7 @@ async function weather() { j.hourly.time.forEach((t, i) => { hourly.push([t.slice(0, 13), ...hourlyVars.map((v) => fmt(j.hourly[v][i], 1))]); }); - await sleep(1500); + await sleep(WEATHER_CHUNK_DELAY_MS); } writeCsv( 'weather-daily.csv', @@ -243,13 +225,7 @@ async function ocean() { `https://marine-api.open-meteo.com/v1/marine?latitude=${LAT + 0.06}&longitude=${LON}` + `&start_date=${s}&end_date=${e}&timezone=${encodeURIComponent(TZ)}` + `&daily=${waveVars.join(',')}${model === 'era5_ocean' ? '&models=era5_ocean' : ''}`; - let j; - try { - j = await get(url, { json: true }); - } catch (err) { - console.warn(`[external] waves ${model} ${s}: ${err.message}`); - continue; - } + const j = await get(url, { json: true }); j.daily.time.forEach((t, i) => { const prev = waves.get(t) ?? {}; for (const v of waveVars) if (prev[v] == null) prev[v] = j.daily[v][i]; @@ -385,10 +361,11 @@ async function chlorophyll() { let text; try { text = await get( - `${base}?chlor_a%5B(${s}T00:00:00Z):1:(${final ? 'last' : `${e}T23:59:59Z`})%5D${box}` + `${base}?chlor_a%5B(${s}T00:00:00Z):1:(${final ? 'last' : `${e}T23:59:59Z`})%5D${box}`, + { retry404: !final } ); } catch (err) { - if (!final) throw err; + if (!final || err.status !== 404) throw err; console.warn(`[external] chlorophyll ${s}…: ${err.message}`); continue; } @@ -609,12 +586,27 @@ const jobs = { cyclones, school }; -for (const [name, job] of Object.entries(jobs)) { - if (!want(name)) continue; - try { - await job(); - } catch (err) { - console.error(`[external] ${name} failed: ${err.message ?? err}`); - process.exitCode = 1; - } +const selected = Object.fromEntries( + Object.entries(jobs) + .filter(([name]) => want(name)) + .map(([name, job]) => [ + name, + async (write) => { + writeSnapshot = write; + await job(); + } + ]) +); +const failed = await refreshJobs(OUT, selected); +if (process.env.GITHUB_STEP_SUMMARY) { + appendFileSync( + process.env.GITHUB_STEP_SUMMARY, + `## Environmental refresh\n\n${Object.keys(selected) + .map( + (name) => + `- ${name}: ${failed.includes(name) ? 'FAILED — retained previous snapshot; see fetch log' : 'refreshed'}` + ) + .join('\n')}\n` + ); } +if (failed.length) process.exitCode = 1; From a61fd2f8cdf3f69b696ebea03a2a3a8ae7db0205 Mon Sep 17 00:00:00 2001 From: luen Date: Wed, 4 Nov 2026 22:09:41 +1000 Subject: [PATCH 2/2] Refresh: name updated files in release notes; allow 120 minutes - Release notes list the files that changed and, after a partial refresh, link the run, instead of always claiming weather, ocean, tide and ENSO. - A full live fetch took 48 minutes on 4 Nov 2026 (NOAA ERDDAP 502/503s and six 120 s stalls), too close to the 60-minute limit. - AGENTS.md: the #159 note sits with the refresh-external.yml bullet. Co-Authored-By: Claude Opus 5.5 --- .github/workflows/refresh-external.yml | 13 +++++++++++-- AGENTS.md | 2 +- 2 files changed, 12 insertions(+), 3 deletions(-) diff --git a/.github/workflows/refresh-external.yml b/.github/workflows/refresh-external.yml index d8ed779..f3c1737 100644 --- a/.github/workflows/refresh-external.yml +++ b/.github/workflows/refresh-external.yml @@ -22,7 +22,8 @@ permissions: jobs: refresh: runs-on: ubuntu-latest - timeout-minutes: 60 + # A full run took 48 minutes on 4 Nov 2026 with NOAA ERDDAP stalls and 429 backoff possible on top. + timeout-minutes: 120 outputs: version: ${{ steps.version.outputs.version }} changed: ${{ steps.diff.outputs.changed }} @@ -64,16 +65,24 @@ jobs: env: GH_TOKEN: ${{ secrets.GITHUB_TOKEN }} VERSION: ${{ steps.version.outputs.version }} + FETCH_OUTCOME: ${{ steps.fetch.outcome }} + RUN_URL: ${{ github.server_url }}/${{ github.repository }}/actions/runs/${{ github.run_id }} run: | set -euo pipefail git config user.name "github-actions[bot]" git config user.email "41898282+github-actions[bot]@users.noreply.github.com" git add external package.json + # Name what changed: after a partial refresh, not every source was updated (#159). + FILES="$(git diff --cached --name-only -- external | sed 's#^external/##' | paste -sd, - | sed 's/,/, /g')" + NOTES="Weekly refresh of the environmental snapshots. Updated: ${FILES}." + if [ "$FETCH_OUTCOME" = "failure" ]; then + NOTES="${NOTES} Some sources failed and kept their previous snapshot; see ${RUN_URL}." + fi git commit -m "chore(data): weekly environmental data refresh (v${VERSION})" git pull --rebase origin main git tag "v${VERSION}" git push origin HEAD:main "v${VERSION}" - gh release create "v${VERSION}" --target main --title "v${VERSION}" --notes "Weekly refresh of weather, ocean, tide and ENSO snapshots." + gh release create "v${VERSION}" --target main --title "v${VERSION}" --notes "$NOTES" docker: needs: refresh diff --git a/AGENTS.md b/AGENTS.md index 83ea921..d1c8f3f 100644 --- a/AGENTS.md +++ b/AGENTS.md @@ -170,8 +170,8 @@ Drop the workbook in `data/` named like `Physioshark_Shark Log 2026-2027.xlsx` ( - `docker-compose.yml` (local build) and `docker-compose.ghcr.yml` (published image). Both mount `${DATA_PATH:-./data}:/data:ro` and a `cache` volume at `/cache`. - `docker-release.yml`: builds linux/amd64 + arm64 and pushes on `v*` tag pushes, manual dispatch or `workflow_call`. Image name is lower-cased from the repo (`rummerlab/data-stats`). - `nightly-minor-deps-release.yml`: `npm-check-updates --target semver --cooldown 3`, full suite, then a patch release + image **only when a package that reaches the image moved** (tooling list in `scripts/nightlyRelease.mjs`; add new lint/test devDependencies there). It pushes to `main`, so branch protection needs a bypass for Actions. -- Environmental refresh (#159): `external-refresh.mjs` stages each source until it completes; a failed fetch retains its old files. HTTP 429 waits at least one minute and honors `Retry-After`; weather chunks pause 10 s. Historical ERDDAP 404s retry, final unpublished chunks do not. The workflow allows fetch failure through publishing, then a separate report job fails after Docker (even if Docker was skipped); source status is in the Actions summary. Do not fail the refresh job before publishing successful sources. - `refresh-external.yml`: weekly `fetch-external.mjs`; when `external/` changed it commits, tags a patch release and publishes the image. +- Partial refreshes (#159): each source writes into a staging folder (`external-refresh.mjs`) and replaces its files only when it finishes, so a failed source keeps its old snapshot and the others still ship. The fetch step may fail (`continue-on-error`); the workflow still commits and releases what changed, and the `report` job turns the run red afterwards (also when Docker was skipped). Don't fail the refresh job before publishing. Release notes list the updated files. The job allows 120 minutes: a full fetch took 48 on 4 Nov 2026, mostly NOAA ERDDAP stalls (each request times out after 120 s and retries). HTTP 429 waits at least a minute (or `Retry-After`), weather chunks are 10 s apart (Open-Meteo counts a long request with many variables as several calls; 1.5 s apart hit its per-minute limit on 2 Nov 2026), and historical ERDDAP 404s are retried; a final chunk's 404 means not yet published. - Dependabot covers GitHub Actions only: its pnpm runs on Node < 26 and `engineStrict` fails every npm job. npm majors are upgraded by hand. - `ci.yml`: lint + check + unit tests, build + Playwright/axe, and a Docker build + smoke test (synthetic fixture) on both architectures. - Runner is distroless `cc-debian13:nonroot` (uid 65532) with the build stage's Node binary: no shell. Debug with `node -e`.