fix: SDK auto-update now actually proxies new names + CI Node 24 opt-in

Phase 4.4 wired the daily ad-patterns.json refresh into
chrome.storage.local.cached_patterns and merged the snapshot into the
isolated-world ai-ad-blocker.js. But the MAIN-world sdk-blocker.js —
the script that actually installs the proxies on the page's window —
only ever saw the bundled patterns. So if the daily refresh added a
new SDK function name (e.g. ChatGPT decides to ship as "OpenAIAds"
tomorrow), DOM selectors picked it up but the actual interceptor
never did. Half-implemented auto-update.

Fix:
- sdk-blocker.js now tracks installed proxies in a Set, exposes
  installProxiesFor(names), and listens for
  {source: 'armorly', type: 'update-sdk-list', functions: [...]}
  messages on the window. The bundled list installs synchronously at
  document_start; the cached list arrives later via the bridge.
- ai-ad-blocker.js, on a successful mergeCachedPatterns(), postMessages
  the merged function list to MAIN world. Same channel ai-ad-blocker
  uses to receive `sdk-blocked` notifications, opposite direction.
- New Playwright test seeds cached_patterns with a synthetic
  "ArmorlyAutoUpdateProbe" function name, opens fake-ads.html, and
  asserts the proxy is installed. Cleans up after itself so other
  tests aren't affected.

CI hygiene
- Switched `npm install` -> `npm ci`. We've been committing
  package-lock.json since v2.8.0, so npm ci is the deterministic
  install that matches it.
- Set FORCE_JAVASCRIPT_ACTIONS_TO_NODE24=true at the workflow level
  on both build.yml and release.yml. Silences the Node 20
  deprecation banner GitHub annotated on every previous run.

All 6 Playwright tests pass. Six-target build still clean.

Co-Authored-By: Claude Opus 4.7 (1M context) <noreply@anthropic.com>

Author: clay-good

.github/workflows/build.yml

@@ -9,6 +9,11 @@ on:
 permissions:
   contents: read
 
+# Opt JavaScript actions into the Node 24 runtime ahead of GitHub's June 2026
+# default flip. Silences the deprecation warning we hit on every run.
+env:
+  FORCE_JAVASCRIPT_ACTIONS_TO_NODE24: "true"
+
 jobs:
   build:
     runs-on: ubuntu-latest
@@ -87,7 +92,7 @@ jobs:
           path: ~/.cache/ms-playwright
           key: pw-${{ runner.os }}-${{ hashFiles('package.json') }}
 
-      - run: npm install
+      - run: npm ci
 
       - run: npx playwright install --with-deps chromium
 

.github/workflows/release.yml

@@ -45,6 +45,11 @@ on:
 permissions:
   contents: write   # needed to create the GitHub Release
 
+# Opt JavaScript actions into the Node 24 runtime ahead of GitHub's June 2026
+# default flip.
+env:
+  FORCE_JAVASCRIPT_ACTIONS_TO_NODE24: "true"
+
 jobs:
   build:
     runs-on: ubuntu-latest

CHANGELOG.md

@@ -4,10 +4,14 @@ All notable user-facing changes to Armorly are documented here. Format loosely f
 
 ## [Unreleased]
 
+### Fixed
+- **Auto-update now actually reaches the SDK interceptor.** Phase 4.4 wired the daily refresh into `chrome.storage.local.cached_patterns` and merged the snapshot into the isolated-world script's patterns object — but the MAIN-world [sdk-blocker.js](extension/content/sdk-blocker.js) only saw the bundled list, so any *newly-named* SDK from the daily refresh was never proxied. Fix: when the isolated-world script merges a newer snapshot, it postMessages the updated function list to the MAIN world; sdk-blocker listens and installs proxies for any names it hasn't seen yet (deduped via a Set). DOM selectors and affiliate params were always being auto-updated correctly; this gap was specific to SDK function-name coverage. New Playwright test seeds a synthetic name in `cached_patterns` and asserts the proxy lands.
+
 ### Added
 - **Automated demo recording (Phase 3).** New ChatGPT-styled fixture page ([tests/fixtures/chatgpt-mock.html](tests/fixtures/chatgpt-mock.html)) plus an off→on storyboard in the `@demo` Playwright test produce a deterministic 7.6-second walkthrough. `./scripts/make-demo-gif.sh` converts the webm to a 900 KB GIF via ffmpeg + gifsicle. Output is committed at [docs/demo.gif](docs/demo.gif) and embedded at the top of the README — what used to require a manual screen recording now lives in the repo and replays exactly the same every build.
 
 ### Changed
+- CI: switched `npm install` → `npm ci` (we have a committed lock file) and set `FORCE_JAVASCRIPT_ACTIONS_TO_NODE24=true` at the workflow level to opt into Node 24 ahead of GitHub's June 2026 default flip. Silences the deprecation banner on every run.
 - **README restructured** along the lines of SPEC.md Phase 1.1: install table moved to the top, "Why ads will destroy AI" essay shifted below the practical sections, developer content consolidated under a single "For developers" heading. Stale facts corrected — limitation #4 now reflects the v2.5.0 pattern auto-update, limitation #12's "no network-level blocking" claim removed (we added that in v2.3.0), the project-structure tree now lists `background.js`, `sdk-blocker.js`, `rules/`, and `ad-patterns.json`. Added a build-status badge linking to the [build workflow](.github/workflows/build.yml).
 - **`npm run demo`** now actually produces a webm. It sets `ARMORLY_DEMO=1`, which flips `recordVideo` on the persistent context and runs only the `@demo`-tagged walkthrough — the existing fixture pages, end to end, at 1280×720. Output lands in `test-results/demo/`.
 

armorly-extension.zip

@@ -369,7 +369,20 @@
       // service worker. Bundled patterns are the floor; this can only ADD.
       if (data.cached_patterns && typeof patterns.mergeCachedPatterns === 'function') {
         const applied = patterns.mergeCachedPatterns(data.cached_patterns);
-        if (applied) console.log('[Armorly] Using cached patterns', patterns.version);
+        if (applied) {
+          console.log('[Armorly] Using cached patterns', patterns.version);
+          // Push the updated SDK function list to the MAIN-world sdk-blocker
+          // so newly-named SDKs from the daily refresh also get proxied.
+          // Without this hop, auto-update only covers DOM selectors and
+          // affiliate params — the actual interceptor stayed bundled-only.
+          try {
+            window.postMessage({
+              source: 'armorly',
+              type: 'update-sdk-list',
+              functions: patterns.getAllSDKFunctions()
+            }, '*');
+          } catch (_) { /* noop */ }
+        }
       }
       init();
     });

extension/content/ai-ad-blocker.js

@@ -19,7 +19,11 @@
   'use strict';
 
   if (!window.ArmorlyAdPatterns) return;
-  const sdkFunctions = window.ArmorlyAdPatterns.getAllSDKFunctions();
+
+  // Names we've already installed proxies for. Used to ignore duplicates
+  // when the isolated-world script later pushes an updated list pulled
+  // from cached_patterns (chrome.storage.local). See message listener below.
+  const installed = new Set();
 
   function createProxy() {
     return new Proxy({}, {
@@ -37,16 +41,38 @@
     });
   }
 
-  sdkFunctions.forEach(function (name) {
-    try {
-      const proxy = createProxy();
-      Object.defineProperty(window, name, {
-        get: function () { return proxy; },
-        set: function () { return true; },
-        configurable: false
-      });
-    } catch (_) {
-      // Property may already be defined non-configurable. Skip.
+  function installProxiesFor(names) {
+    if (!Array.isArray(names)) return;
+    for (const name of names) {
+      if (typeof name !== 'string' || installed.has(name)) continue;
+      try {
+        const proxy = createProxy();
+        Object.defineProperty(window, name, {
+          get: function () { return proxy; },
+          set: function () { return true; },
+          configurable: false
+        });
+        installed.add(name);
+      } catch (_) {
+        // Property may already be defined non-configurable on the page; skip.
+      }
+    }
+  }
+
+  // First pass: install from the bundled patterns. Runs synchronously at
+  // document_start so the proxy lands before any inline ad-SDK call.
+  installProxiesFor(window.ArmorlyAdPatterns.getAllSDKFunctions());
+
+  // Second pass: when ai-ad-blocker.js (isolated world) finishes its
+  // chrome.storage.local lookup and merges cached_patterns, it postMessages
+  // the updated function list to us so we can proxy any names the daily
+  // background refresh added since the bundle was packaged.
+  window.addEventListener('message', function (event) {
+    if (event.source !== window) return;
+    const data = event.data;
+    if (!data || data.source !== 'armorly') return;
+    if (data.type === 'update-sdk-list' && Array.isArray(data.functions)) {
+      installProxiesFor(data.functions);
     }
   });
 })();

extension/content/sdk-blocker.js

@@ -151,6 +151,46 @@ test('@demo end-to-end ChatGPT-mock walkthrough for the hero video', async () =>
   await worker.evaluate(() => chrome.storage.local.set({ disabled_domains: [] }));
 });
 
+test('auto-update bridge: cached pattern SDK names reach the MAIN-world interceptor', async () => {
+  // SPEC.md Phase 4.4 was originally only wired to the isolated-world script,
+  // so newly-added SDK function names from the daily refresh never got
+  // proxied. This test seeds a synthetic name in `cached_patterns`, opens a
+  // page, and asserts the MAIN-world sdk-blocker installed a proxy for it.
+  let [worker] = context.serviceWorkers();
+  if (!worker) worker = await context.waitForEvent('serviceworker');
+
+  await worker.evaluate(() =>
+    chrome.storage.local.set({
+      cached_patterns: {
+        version: '9999-12-31', // strictly newer than BUNDLED_VERSION
+        adSDKs: {
+          future_network: {
+            functions: ['ArmorlyAutoUpdateProbe'],
+            methods: ['init'],
+            domainPatterns: []
+          }
+        }
+      }
+    })
+  );
+
+  const page = await context.newPage();
+  await page.goto(`${FIXTURES}/fake-ads.html`);
+
+  // The bridge is async: ai-ad-blocker's storage callback resolves, it
+  // postMessages the new function list, sdk-blocker proxies it. Allow up
+  // to 5s for the round trip — typically lands in well under 100ms.
+  await page.waitForFunction(
+    () => typeof (window as any).ArmorlyAutoUpdateProbe !== 'undefined',
+    undefined,
+    { timeout: 5000 }
+  );
+  expect(await page.evaluate(() => typeof (window as any).ArmorlyAutoUpdateProbe)).toBe('object');
+
+  // Cleanup so the rest of the suite isn't influenced by a fake cached snapshot.
+  await worker.evaluate(() => chrome.storage.local.set({ cached_patterns: null }));
+});
+
 test('hidden-content shield empties white-on-white injection but leaves visible content', async () => {
   const page = await context.newPage();
   await page.goto(`${FIXTURES}/hidden-injection.html`);