ultimate-jekyll-manager 1.9.0 → 1.9.2

package/dist/test/suites/page/form-manager-validation.test.js

@@ -0,0 +1,374 @@
+// FormManager validation: HTML5 constraint validation (required, email, min,
+// max, minlength, maxlength, pattern), honeypot detection, and file-accept
+// matching. Logic inlined from form-manager.js.
+
+module.exports = {
+  layer: 'page',
+  description: 'FormManager validation + honeypot + file-accept',
+  type: 'group',
+  tests: [
+    // ── Required validation ────────────────────────────────────────────
+    {
+      name: 'required text field fails when empty, passes when filled',
+      run: async (ctx) => {
+        var form = document.createElement('form');
+        form.innerHTML = '<input type="text" name="name" required>';
+        document.body.appendChild(form);
+
+        var errors = {};
+        var $f = form.querySelector('[name="name"]');
+
+        // Empty → error
+        if ($f.hasAttribute('required') && (!$f.value || !$f.value.trim())) {
+          errors['name'] = 'required';
+        }
+        ctx.expect(errors['name']).toBe('required');
+
+        // Filled → no error
+        errors = {};
+        $f.value = 'Ian';
+        if ($f.hasAttribute('required') && (!$f.value || !$f.value.trim())) {
+          errors['name'] = 'required';
+        }
+        ctx.expect(errors['name']).toBe(undefined);
+
+        form.remove();
+      },
+    },
+    {
+      name: 'required checkbox fails when unchecked',
+      run: async (ctx) => {
+        var form = document.createElement('form');
+        form.innerHTML = '<input type="checkbox" name="terms" required>';
+        document.body.appendChild(form);
+
+        var errors = {};
+        var $f = form.querySelector('[name="terms"]');
+
+        if ($f.hasAttribute('required') && $f.type === 'checkbox' && !$f.checked) {
+          errors['terms'] = 'required';
+        }
+        ctx.expect(errors['terms']).toBe('required');
+
+        $f.checked = true;
+        errors = {};
+        if ($f.hasAttribute('required') && $f.type === 'checkbox' && !$f.checked) {
+          errors['terms'] = 'required';
+        }
+        ctx.expect(errors['terms']).toBe(undefined);
+
+        form.remove();
+      },
+    },
+    {
+      name: 'required radio group fails when none checked',
+      run: async (ctx) => {
+        var form = document.createElement('form');
+        form.innerHTML = '<input type="radio" name="plan" value="a" required>'
+          + '<input type="radio" name="plan" value="b" required>';
+        document.body.appendChild(form);
+
+        var errors = {};
+        var $checked = form.querySelector('input[name="plan"]:checked');
+        if (!$checked) {
+          errors['plan'] = 'required';
+        }
+        ctx.expect(errors['plan']).toBe('required');
+
+        form.querySelector('[value="b"]').checked = true;
+        errors = {};
+        $checked = form.querySelector('input[name="plan"]:checked');
+        if (!$checked) {
+          errors['plan'] = 'required';
+        }
+        ctx.expect(errors['plan']).toBe(undefined);
+
+        form.remove();
+      },
+    },
+
+    // ── Email validation ───────────────────────────────────────────────
+    {
+      name: 'email validation rejects invalid formats and accepts valid ones',
+      run: async (ctx) => {
+        var emailPattern = /^[^\s@]+@[^\s@]+\.[^\s@]+$/;
+
+        ctx.expect(emailPattern.test('ian@example.com')).toBe(true);
+        ctx.expect(emailPattern.test('user+tag@sub.domain.co')).toBe(true);
+        ctx.expect(emailPattern.test('bad')).toBe(false);
+        ctx.expect(emailPattern.test('no@tld')).toBe(false);
+        ctx.expect(emailPattern.test('@missing.com')).toBe(false);
+        ctx.expect(emailPattern.test('spaces @test.com')).toBe(false);
+      },
+    },
+
+    // ── Min/max value validation ───────────────────────────────────────
+    {
+      name: 'number min/max validation catches out-of-range values',
+      run: async (ctx) => {
+        var form = document.createElement('form');
+        form.innerHTML = '<input type="number" name="age" min="18" max="120">';
+        document.body.appendChild(form);
+
+        var $f = form.querySelector('[name="age"]');
+
+        function validate(value) {
+          $f.value = value;
+          if ($f.hasAttribute('min') && parseFloat($f.value) < parseFloat($f.getAttribute('min'))) return 'too-low';
+          if ($f.hasAttribute('max') && parseFloat($f.value) > parseFloat($f.getAttribute('max'))) return 'too-high';
+          return 'ok';
+        }
+
+        ctx.expect(validate('17')).toBe('too-low');
+        ctx.expect(validate('18')).toBe('ok');
+        ctx.expect(validate('50')).toBe('ok');
+        ctx.expect(validate('120')).toBe('ok');
+        ctx.expect(validate('121')).toBe('too-high');
+
+        form.remove();
+      },
+    },
+
+    // ── Minlength / maxlength validation ───────────────────────────────
+    {
+      name: 'minlength and maxlength validation',
+      run: async (ctx) => {
+        var form = document.createElement('form');
+        form.innerHTML = '<input type="text" name="code" minlength="3" maxlength="10">';
+        document.body.appendChild(form);
+
+        var $f = form.querySelector('[name="code"]');
+
+        function validate(value) {
+          $f.value = value;
+          var minLen = parseInt($f.getAttribute('minlength'), 10);
+          var maxLen = parseInt($f.getAttribute('maxlength'), 10);
+          if ($f.value.length < minLen) return 'too-short';
+          if ($f.value.length > maxLen) return 'too-long';
+          return 'ok';
+        }
+
+        ctx.expect(validate('ab')).toBe('too-short');
+        ctx.expect(validate('abc')).toBe('ok');
+        ctx.expect(validate('abcdefghij')).toBe('ok');
+        ctx.expect(validate('abcdefghijk')).toBe('too-long');
+
+        form.remove();
+      },
+    },
+
+    // ── Pattern validation ─────────────────────────────────────────────
+    {
+      name: 'pattern attribute validation',
+      run: async (ctx) => {
+        var form = document.createElement('form');
+        form.innerHTML = '<input type="text" name="zip" pattern="[0-9]{5}" title="5-digit zip">';
+        document.body.appendChild(form);
+
+        var $f = form.querySelector('[name="zip"]');
+
+        function validate(value) {
+          $f.value = value;
+          var pattern = new RegExp('^' + $f.getAttribute('pattern') + '$');
+          return pattern.test($f.value);
+        }
+
+        ctx.expect(validate('12345')).toBe(true);
+        ctx.expect(validate('1234')).toBe(false);
+        ctx.expect(validate('123456')).toBe(false);
+        ctx.expect(validate('abcde')).toBe(false);
+
+        form.remove();
+      },
+    },
+
+    // ── Honeypot detection ─────────────────────────────────────────────
+    {
+      name: 'honeypot detection catches [data-honey] and [name="honey"] fields',
+      run: async (ctx) => {
+        var HONEYPOT_SELECTOR = '[data-honey], [name="honey"]';
+
+        // Form with empty honeypot → not filled
+        var form = document.createElement('form');
+        form.innerHTML = '<input type="text" name="email" value="real">'
+          + '<input type="text" name="honey" data-honey value="">';
+        document.body.appendChild(form);
+
+        function isHoneypotFilled(f) {
+          var pots = f.querySelectorAll(HONEYPOT_SELECTOR);
+          for (var i = 0; i < pots.length; i++) {
+            if (pots[i].value && pots[i].value.trim() !== '') return true;
+          }
+          return false;
+        }
+
+        ctx.expect(isHoneypotFilled(form)).toBe(false);
+
+        // Fill the honeypot → detected
+        form.querySelector('[name="honey"]').value = 'bot-spam';
+        ctx.expect(isHoneypotFilled(form)).toBe(true);
+
+        form.remove();
+      },
+    },
+    {
+      name: 'honeypot detects data-honey without name="honey"',
+      run: async (ctx) => {
+        var HONEYPOT_SELECTOR = '[data-honey], [name="honey"]';
+
+        var form = document.createElement('form');
+        form.innerHTML = '<input type="text" name="realfield" value="ok">'
+          + '<input type="text" name="decoy" data-honey value="">';
+        document.body.appendChild(form);
+
+        function isHoneypotFilled(f) {
+          var pots = f.querySelectorAll(HONEYPOT_SELECTOR);
+          for (var i = 0; i < pots.length; i++) {
+            if (pots[i].value && pots[i].value.trim() !== '') return true;
+          }
+          return false;
+        }
+
+        ctx.expect(isHoneypotFilled(form)).toBe(false);
+
+        form.querySelector('[data-honey]').value = 'filled';
+        ctx.expect(isHoneypotFilled(form)).toBe(true);
+
+        form.remove();
+      },
+    },
+
+    // ── _fileMatchesAccept ─────────────────────────────────────────────
+    {
+      name: 'file-accept matching: extension, wildcard MIME, exact MIME',
+      run: async (ctx) => {
+        function fileMatchesAccept(fileName, fileType, accept) {
+          var types = accept.split(',').map(function (t) { return t.trim().toLowerCase(); });
+          fileName = fileName.toLowerCase();
+          fileType = (fileType || '').toLowerCase();
+          var extToCategory = {
+            '.jpg': 'image/', '.jpeg': 'image/', '.png': 'image/', '.gif': 'image/',
+            '.webp': 'image/', '.svg': 'image/', '.pdf': 'application/pdf',
+          };
+
+          for (var i = 0; i < types.length; i++) {
+            var type = types[i];
+            if (type.startsWith('.')) {
+              if (fileName.endsWith(type)) return true;
+              continue;
+            }
+            if (type.endsWith('/*')) {
+              var prefix = type.slice(0, -2) + '/';
+              if (fileType && fileType.startsWith(prefix)) return true;
+              if (!fileType) {
+                var ext = '.' + fileName.split('.').pop();
+                var guessed = extToCategory[ext] || '';
+                if (guessed.startsWith(prefix)) return true;
+              }
+              continue;
+            }
+            if (fileType === type) return true;
+          }
+          return false;
+        }
+
+        // Extension matching
+        ctx.expect(fileMatchesAccept('doc.pdf', 'application/pdf', '.pdf')).toBe(true);
+        ctx.expect(fileMatchesAccept('doc.txt', 'text/plain', '.pdf')).toBe(false);
+
+        // Wildcard MIME
+        ctx.expect(fileMatchesAccept('photo.jpg', 'image/jpeg', 'image/*')).toBe(true);
+        ctx.expect(fileMatchesAccept('photo.png', 'image/png', 'image/*')).toBe(true);
+        ctx.expect(fileMatchesAccept('doc.pdf', 'application/pdf', 'image/*')).toBe(false);
+
+        // Exact MIME
+        ctx.expect(fileMatchesAccept('doc.pdf', 'application/pdf', 'application/pdf')).toBe(true);
+        ctx.expect(fileMatchesAccept('doc.pdf', 'application/pdf', 'text/plain')).toBe(false);
+
+        // Multi-accept
+        ctx.expect(fileMatchesAccept('photo.jpg', 'image/jpeg', '.pdf,image/*')).toBe(true);
+        ctx.expect(fileMatchesAccept('doc.pdf', 'application/pdf', '.pdf,image/*')).toBe(true);
+        ctx.expect(fileMatchesAccept('code.js', 'text/javascript', '.pdf,image/*')).toBe(false);
+
+        // Extension fallback when MIME type is empty
+        ctx.expect(fileMatchesAccept('photo.jpg', '', 'image/*')).toBe(true);
+        ctx.expect(fileMatchesAccept('photo.png', '', 'image/*')).toBe(true);
+        ctx.expect(fileMatchesAccept('unknown.xyz', '', 'image/*')).toBe(false);
+      },
+    },
+
+    // ── Field error display ────────────────────────────────────────────
+    {
+      name: 'field error display adds is-invalid class and feedback element',
+      run: async (ctx) => {
+        var form = document.createElement('form');
+        form.innerHTML = '<div class="mb-3"><input type="text" name="email" class="form-control"></div>';
+        document.body.appendChild(form);
+
+        var $field = form.querySelector('[name="email"]');
+
+        // Show error
+        $field.classList.add('is-invalid');
+        var $feedback = document.createElement('div');
+        $feedback.className = 'invalid-feedback';
+        $feedback.textContent = 'Email is required';
+        $feedback.style.display = 'block';
+        $field.parentElement.appendChild($feedback);
+
+        ctx.expect($field.classList.contains('is-invalid')).toBe(true);
+        var $fb = $field.parentElement.querySelector('.invalid-feedback');
+        ctx.expect($fb).toBeTruthy();
+        ctx.expect($fb.textContent).toBe('Email is required');
+
+        // Clear error
+        $field.classList.remove('is-invalid');
+        $fb.style.display = 'none';
+        ctx.expect($field.classList.contains('is-invalid')).toBe(false);
+
+        form.remove();
+      },
+    },
+
+    // ── Query param population ─────────────────────────────────────────
+    {
+      name: 'query param population skips UTM/tracking params',
+      run: async (ctx) => {
+        var skipPrefixes = ['utm_', 'itm_'];
+        var skipExact = ['cb', 'fbclid', 'gclid'];
+
+        function shouldSkip(key) {
+          for (var i = 0; i < skipPrefixes.length; i++) {
+            if (key.startsWith(skipPrefixes[i])) return true;
+          }
+          return skipExact.indexOf(key) !== -1;
+        }
+
+        ctx.expect(shouldSkip('utm_source')).toBe(true);
+        ctx.expect(shouldSkip('utm_campaign')).toBe(true);
+        ctx.expect(shouldSkip('itm_source')).toBe(true);
+        ctx.expect(shouldSkip('cb')).toBe(true);
+        ctx.expect(shouldSkip('fbclid')).toBe(true);
+        ctx.expect(shouldSkip('gclid')).toBe(true);
+        ctx.expect(shouldSkip('email')).toBe(false);
+        ctx.expect(shouldSkip('name')).toBe(false);
+      },
+    },
+
+    // ── State attribute ────────────────────────────────────────────────
+    {
+      name: 'data-form-state attribute reflects state transitions',
+      run: async (ctx) => {
+        var form = document.createElement('form');
+        document.body.appendChild(form);
+
+        var states = ['initializing', 'ready', 'submitting', 'ready', 'submitted'];
+        states.forEach(function (s) {
+          form.setAttribute('data-form-state', s);
+          ctx.expect(form.getAttribute('data-form-state')).toBe(s);
+        });
+
+        form.remove();
+      },
+    },
+  ],
+};

package/docs/javascript-libraries.md

@@ -387,12 +387,22 @@ Errors display with Bootstrap's `is-invalid` class and `.invalid-feedback` eleme
 
 When the form transitions to `ready` state, FormManager automatically focuses the field with the `autofocus` attribute (if present and not disabled).
 
-**Permanently-disabled fields (`data-fm-keep-disabled`):**
+**Permanently-disabled fields (snapshot model):**
 
-FormManager blanket-toggles `disabled` on every control in the form while loading/submitting and re-enables them on `ready`/error. Fields that must STAY disabled (e.g. "coming soon" options rendered inside a managed form) opt out with the `data-fm-keep-disabled` attribute — the toggle always forces them to `disabled = true` and never re-enables them:
+FormManager snapshots every element that has `disabled` in HTML markup at init time (excluding `type="submit"` buttons, which are treated as loading guards). Snapshotted elements stay disabled through every state transition — no data attributes needed. Just put `disabled` on the element in HTML:
 
 ```html
-<input type="radio" name="plan" value="enterprise" disabled data-fm-keep-disabled>
+<input type="radio" name="plan" value="enterprise" disabled>
+<select name="region" disabled>...</select>
+```
+
+Submit buttons can still use `disabled` in HTML as a loading guard — FM always manages them regardless of initial state. For full pre-JS protection, add `data-form-state="initializing"` and `onsubmit="return false"` to the `<form>` tag, with CSS to block interaction:
+
+```css
+form[data-form-state]:not([data-form-state="ready"]) {
+  pointer-events: none;
+  opacity: 0.6;
+}
 ```
 
 **Methods:**

package/logs/test.log

@@ -1,31 +1,31 @@
-# ujm log — 2026-06-17T22:01:06.463Z — pid=85523
-[15:01:06] 'test': Running tests (layer=all)
-[15:01:06] 'test': Test mode: normal (external APIs skipped)
+# ujm log — 2026-06-18T02:44:23.186Z — pid=67215
+[19:44:23] 'test': Running tests (layer=all)
+[19:44:23] 'test': Test mode: normal (external APIs skipped)
 
   Ultimate Jekyll Manager Tests
 
   Framework Tests
     ⤷ attach-log-file — tee stdout/stderr to a file
       ✓ exports the expected surface (0ms)
-      ✓ stripAnsi removes color escape codes (1ms)
+      ✓ stripAnsi removes color escape codes (0ms)
 hello world
 colored line
       ✓ attach + stdout.write + detach: file contains the writes (0ms)
       ✓ idempotent: attaching twice with same name returns same fd (0ms)
       ✓ attach with falsy name returns null and does nothing (0ms)
     ⤷ CLI alias resolution
-      ✓ cli.js exports a Main class (1ms)
-      ✓ all expected commands exist on disk (0ms)
-      ✓ each command module exports an async function (8ms)
+      ✓ cli.js exports a Main class (0ms)
+      ✓ all expected commands exist on disk (1ms)
+      ✓ each command module exports an async function (3ms)
     ⤷ collectTextNodes (utils/collectTextNodes.js)
-      ✓ extracts page title (134ms)
+      ✓ extracts page title (107ms)
       ✓ skips <script> and <style> (1ms)
-    ✓ spellcheck dictionary (utils/dictionary.js) (0ms)
+    ✓ spellcheck dictionary (utils/dictionary.js) (1ms)
     ⤷ expect() matcher set
       ✓ toBe + toEqual basics (0ms)
       ✓ .not negates (0ms)
       ✓ toContain works on arrays and strings (0ms)
-      ✓ toThrow catches sync + async throws (1ms)
+      ✓ toThrow catches sync + async throws (0ms)
       ✓ toBeGreaterThan / toBeLessThan (0ms)
       ✓ failing assertions throw AssertionError (0ms)
     ✓ package.json exports resolve to real files in dist/ (0ms)
@@ -44,16 +44,16 @@ colored line
       ✓ actLikeProduction is true when isBuildMode OR UJ_AUDIT_FORCE (0ms)
       ✓ getRootPath("package") points at UJM root (0ms)
       ✓ getMemoryUsage returns shape with MB-sized numbers (0ms)
-      ✓ getArguments returns object with _ array + boolean defaults (1ms)
+      ✓ getArguments returns object with _ array + boolean defaults (0ms)
       ✓ logger returns object with log/error/warn/info methods (0ms)
       ✓ processBatches processes items in chunks and returns flat results (0ms)
     ⤷ mergeJekyllConfigs (utils/merge-jekyll-configs.js)
       ✓ merges collections from both configs (project additions win) (3ms)
       ✓ dedups defaults by scope key (project wins) (1ms)
-      ✓ returns null when there is nothing to merge (0ms)
+      ✓ returns null when there is nothing to merge (1ms)
     ⤷ mode-helpers (isTesting / isDevelopment / isProduction / getVersion)
       ✓ helpers attach to Manager statically AND on prototype (0ms)
-      ✓ isTesting reflects UJ_TEST_MODE env (1ms)
+      ✓ isTesting reflects UJ_TEST_MODE env (0ms)
       ✓ isDevelopment false / isProduction true when UJ_BUILD_MODE=true (and not testing) (0ms)
       ✓ environments are mutually exclusive — testing wins under UJ_TEST_MODE (0ms)
       ✓ invariant: is*() exactly matches getEnvironment() + mutually exclusive (every scenario) (0ms)
@@ -63,49 +63,82 @@ colored line
       ✓ leaves non-matching extensions untouched (e.g. .css) (0ms)
       ✓ passes directories through untouched (0ms)
     ⤷ node-powertools templating brackets ({} and [])
-      ✓ default { } brackets resolve nested keys (0ms)
+      ✓ default { } brackets resolve nested keys (1ms)
       ✓ [ ] brackets resolve nested keys when explicitly configured (0ms)
       ✓ [ ] brackets leave Jekyll {{ }} placeholders alone (0ms)
     ⤷ theme contract (structure, swappability, cross-theme JS contracts)
       ✓ _template: entry files + config contract (0ms)
-      ✓ classy: entry files + config contract (0ms)
-      ✓ neobrutalism: entry files + config contract (1ms)
+      ✓ classy: entry files + config contract (1ms)
+      ✓ neobrutalism: entry files + config contract (0ms)
       ✓ newsflash: entry files + config contract (0ms)
-      ✓ _template: layouts swappable, markup clean (1ms)
-      ✓ classy: layouts swappable, markup clean (14ms)
-      ✓ neobrutalism: layouts swappable, markup clean (1ms)
-      ✓ newsflash: layouts swappable, markup clean (3ms)
+      ✓ _template: layouts swappable, markup clean (2ms)
+      ✓ classy: layouts swappable, markup clean (15ms)
+      ✓ neobrutalism: layouts swappable, markup clean (2ms)
+      ✓ newsflash: layouts swappable, markup clean (2ms)
       ✓ _template: cross-theme JS contracts (0ms)
-      ✓ classy: cross-theme JS contracts (0ms)
-      ✓ neobrutalism: cross-theme JS contracts (1ms)
-      ✓ newsflash: cross-theme JS contracts (0ms)
-      ✓ page asset files match a declared asset_path shape (4ms)
+      ✓ classy: cross-theme JS contracts (1ms)
+      ✓ neobrutalism: cross-theme JS contracts (0ms)
+      ✓ newsflash: cross-theme JS contracts (1ms)
+      ✓ page asset files match a declared asset_path shape (3ms)
     ⤷ validateYAMLFrontMatter (utils/_validate-yaml.js)
-      ✓ returns { valid: true } for a file with valid frontmatter (1ms)
-      ✓ returns { valid: true } when no frontmatter present (0ms)
+      ✓ returns { valid: true } for a file with valid frontmatter (0ms)
+      ✓ returns { valid: true } when no frontmatter present (1ms)
       ✓ flags malformed YAML frontmatter as invalid with error message (0ms)
     ⤷ page-layer baseline (DOM + fetch + storage)
-      ✓ document is interactive or complete (0ms)
-      ✓ fetch() works against the local harness server (2ms)
-      ✓ localStorage is available (0ms)
+      ✓ document is interactive or complete (1ms)
+      ✓ fetch() works against the local harness server (11ms)
+      ✓ localStorage is available (2ms)
+    ⤷ FormManager getData / setData / input groups
+      ✓ _setNested builds nested objects from dot paths (1ms)
+      ✓ _setNested accumulates duplicate keys into arrays (1ms)
+      ✓ _getNested reads nested values and returns undefined for missing paths (0ms)
+      ✓ _flattenObject converts nested objects to dot paths (2ms)
+      ✓ getData collects text, select, radio, and textarea values with dot notation (8ms)
+      ✓ getData handles single checkbox (boolean) and checkbox groups (object) (1ms)
+      ✓ getData excludes honeypot fields (0ms)
+      ✓ input group filter includes matching + global fields, excludes others (0ms)
+      ✓ input group filter with multiple groups includes all matching (0ms)
+      ✓ setData populates text, select, textarea fields (1ms)
+      ✓ setData sets radio group to matching value (0ms)
+      ✓ setData sets single checkbox boolean and checkbox group values (0ms)
+    ⤷ FormManager disabled-state snapshot
+      ✓ snapshot captures disabled non-submit elements, ignores submit buttons (0ms)
+      ✓ setDisabled(true) disables everything (1ms)
+      ✓ setDisabled(false) re-enables managed elements but keeps snapshotted ones disabled (0ms)
+      ✓ survives multiple disable/enable cycles (0ms)
+      ✓ onsubmit="return false" blocks native submission before FM loads (20ms)
+    ⤷ FormManager validation + honeypot + file-accept
+      ✓ required text field fails when empty, passes when filled (0ms)
+      ✓ required checkbox fails when unchecked (0ms)
+      ✓ required radio group fails when none checked (0ms)
+      ✓ email validation rejects invalid formats and accepts valid ones (3ms)
+      ✓ number min/max validation catches out-of-range values (1ms)
+      ✓ minlength and maxlength validation (0ms)
+      ✓ pattern attribute validation (0ms)
+      ✓ honeypot detection catches [data-honey] and [name="honey"] fields (0ms)
+      ✓ honeypot detects data-honey without name="honey" (0ms)
+      ✓ file-accept matching: extension, wildcard MIME, exact MIME (1ms)
+      ✓ field error display adds is-invalid class and feedback element (0ms)
+      ✓ query param population skips UTM/tracking params (0ms)
+      ✓ data-form-state attribute reflects state transitions (0ms)
     ⤷ harness globals (window.Configuration + dataset)
       ✓ window.Configuration has brand + theme + web_manager (0ms)
       ✓ document.documentElement.dataset.pagePath is set (0ms)
       ✓ UJ_TEST_MODE is signalled on globalThis (0ms)
     ⤷ prerendered icons template lookup
-      ✓ template#prerendered-icons exists and has the test icon (0ms)
+      ✓ template#prerendered-icons exists and has the test icon (1ms)
       ✓ looking up a missing icon returns null (0ms)
     ⤷ boot tests (consumer _site/)
-      ✓ /service-worker.js served with javascript content type (94ms)
-      ✓ index.html registers SW and reaches activated state (146ms)
-      ✓ SW responds to get-cache-name message with brand-id pattern (76ms)
-      ✓ home page renders with title + body content (171ms)
-      ✓ /about resolves via Jekyll-style .html fallback (75ms)
-      ✓ build.json is served with brand metadata (67ms)
-      ✓ CSS bundle served with text/css content type (70ms)
+      ✓ /service-worker.js served with javascript content type (97ms)
+      ✓ index.html registers SW and reaches activated state (251ms)
+      ✓ SW responds to get-cache-name message with brand-id pattern (85ms)
+      ✓ home page renders with title + body content (184ms)
+      ✓ /about resolves via Jekyll-style .html fallback (71ms)
+      ✓ build.json is served with brand metadata (78ms)
+      ✓ CSS bundle served with text/css content type (73ms)
 
   Results
-    80 passing
+    110 passing
 
-    Total: 80 tests in 6044ms
+    Total: 110 tests in 3457ms
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "ultimate-jekyll-manager",
-  "version": "1.9.0",
+  "version": "1.9.2",
   "description": "Ultimate Jekyll dependency manager",
   "main": "dist/index.js",
   "exports": {