@geonosis/walk 1.0.0

package/LICENSE

@@ -0,0 +1,202 @@
+
+                                 Apache License
+                           Version 2.0, January 2004
+                        http://www.apache.org/licenses/
+
+   TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION
+
+   1. Definitions.
+
+      "License" shall mean the terms and conditions for use, reproduction,
+      and distribution as defined by Sections 1 through 9 of this document.
+
+      "Licensor" shall mean the copyright owner or entity authorized by
+      the copyright owner that is granting the License.
+
+      "Legal Entity" shall mean the union of the acting entity and all
+      other entities that control, are controlled by, or are under common
+      control with that entity. For the purposes of this definition,
+      "control" means (i) the power, direct or indirect, to cause the
+      direction or management of such entity, whether by contract or
+      otherwise, or (ii) ownership of fifty percent (50%) or more of the
+      outstanding shares, or (iii) beneficial ownership of such entity.
+
+      "You" (or "Your") shall mean an individual or Legal Entity
+      exercising permissions granted by this License.
+
+      "Source" form shall mean the preferred form for making modifications,
+      including but not limited to software source code, documentation
+      source, and configuration files.
+
+      "Object" form shall mean any form resulting from mechanical
+      transformation or translation of a Source form, including but
+      not limited to compiled object code, generated documentation,
+      and conversions to other media types.
+
+      "Work" shall mean the work of authorship, whether in Source or
+      Object form, made available under the License, as indicated by a
+      copyright notice that is included in or attached to the work
+      (an example is provided in the Appendix below).
+
+      "Derivative Works" shall mean any work, whether in Source or Object
+      form, that is based on (or derived from) the Work and for which the
+      editorial revisions, annotations, elaborations, or other modifications
+      represent, as a whole, an original work of authorship. For the purposes
+      of this License, Derivative Works shall not include works that remain
+      separable from, or merely link (or bind by name) to the interfaces of,
+      the Work and Derivative Works thereof.
+
+      "Contribution" shall mean any work of authorship, including
+      the original version of the Work and any modifications or additions
+      to that Work or Derivative Works thereof, that is intentionally
+      submitted to Licensor for inclusion in the Work by the copyright owner
+      or by an individual or Legal Entity authorized to submit on behalf of
+      the copyright owner. For the purposes of this definition, "submitted"
+      means any form of electronic, verbal, or written communication sent
+      to the Licensor or its representatives, including but not limited to
+      communication on electronic mailing lists, source code control systems,
+      and issue tracking systems that are managed by, or on behalf of, the
+      Licensor for the purpose of discussing and improving the Work, but
+      excluding communication that is conspicuously marked or otherwise
+      designated in writing by the copyright owner as "Not a Contribution."
+
+      "Contributor" shall mean Licensor and any individual or Legal Entity
+      on behalf of whom a Contribution has been received by Licensor and
+      subsequently incorporated within the Work.
+
+   2. Grant of Copyright License. Subject to the terms and conditions of
+      this License, each Contributor hereby grants to You a perpetual,
+      worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+      copyright license to reproduce, prepare Derivative Works of,
+      publicly display, publicly perform, sublicense, and distribute the
+      Work and such Derivative Works in Source or Object form.
+
+   3. Grant of Patent License. Subject to the terms and conditions of
+      this License, each Contributor hereby grants to You a perpetual,
+      worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+      (except as stated in this section) patent license to make, have made,
+      use, offer to sell, sell, import, and otherwise transfer the Work,
+      where such license applies only to those patent claims licensable
+      by such Contributor that are necessarily infringed by their
+      Contribution(s) alone or by combination of their Contribution(s)
+      with the Work to which such Contribution(s) was submitted. If You
+      institute patent litigation against any entity (including a
+      cross-claim or counterclaim in a lawsuit) alleging that the Work
+      or a Contribution incorporated within the Work constitutes direct
+      or contributory patent infringement, then any patent licenses
+      granted to You under this License for that Work shall terminate
+      as of the date such litigation is filed.
+
+   4. Redistribution. You may reproduce and distribute copies of the
+      Work or Derivative Works thereof in any medium, with or without
+      modifications, and in Source or Object form, provided that You
+      meet the following conditions:
+
+      (a) You must give any other recipients of the Work or
+          Derivative Works a copy of this License; and
+
+      (b) You must cause any modified files to carry prominent notices
+          stating that You changed the files; and
+
+      (c) You must retain, in the Source form of any Derivative Works
+          that You distribute, all copyright, patent, trademark, and
+          attribution notices from the Source form of the Work,
+          excluding those notices that do not pertain to any part of
+          the Derivative Works; and
+
+      (d) If the Work includes a "NOTICE" text file as part of its
+          distribution, then any Derivative Works that You distribute must
+          include a readable copy of the attribution notices contained
+          within such NOTICE file, excluding those notices that do not
+          pertain to any part of the Derivative Works, in at least one
+          of the following places: within a NOTICE text file distributed
+          as part of the Derivative Works; within the Source form or
+          documentation, if provided along with the Derivative Works; or,
+          within a display generated by the Derivative Works, if and
+          wherever such third-party notices normally appear. The contents
+          of the NOTICE file are for informational purposes only and
+          do not modify the License. You may add Your own attribution
+          notices within Derivative Works that You distribute, alongside
+          or as an addendum to the NOTICE text from the Work, provided
+          that such additional attribution notices cannot be construed
+          as modifying the License.
+
+      You may add Your own copyright statement to Your modifications and
+      may provide additional or different license terms and conditions
+      for use, reproduction, or distribution of Your modifications, or
+      for any such Derivative Works as a whole, provided Your use,
+      reproduction, and distribution of the Work otherwise complies with
+      the conditions stated in this License.
+
+   5. Submission of Contributions. Unless You explicitly state otherwise,
+      any Contribution intentionally submitted for inclusion in the Work
+      by You to the Licensor shall be under the terms and conditions of
+      this License, without any additional terms or conditions.
+      Notwithstanding the above, nothing herein shall supersede or modify
+      the terms of any separate license agreement you may have executed
+      with Licensor regarding such Contributions.
+
+   6. Trademarks. This License does not grant permission to use the trade
+      names, trademarks, service marks, or product names of the Licensor,
+      except as required for reasonable and customary use in describing the
+      origin of the Work and reproducing the content of the NOTICE file.
+
+   7. Disclaimer of Warranty. Unless required by applicable law or
+      agreed to in writing, Licensor provides the Work (and each
+      Contributor provides its Contributions) on an "AS IS" BASIS,
+      WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
+      implied, including, without limitation, any warranties or conditions
+      of TITLE, NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A
+      PARTICULAR PURPOSE. You are solely responsible for determining the
+      appropriateness of using or redistributing the Work and assume any
+      risks associated with Your exercise of permissions under this License.
+
+   8. Limitation of Liability. In no event and under no legal theory,
+      whether in tort (including negligence), contract, or otherwise,
+      unless required by applicable law (such as deliberate and grossly
+      negligent acts) or agreed to in writing, shall any Contributor be
+      liable to You for damages, including any direct, indirect, special,
+      incidental, or consequential damages of any character arising as a
+      result of this License or out of the use or inability to use the
+      Work (including but not limited to damages for loss of goodwill,
+      work stoppage, computer failure or malfunction, or any and all
+      other commercial damages or losses), even if such Contributor
+      has been advised of the possibility of such damages.
+
+   9. Accepting Warranty or Additional Liability. While redistributing
+      the Work or Derivative Works thereof, You may choose to offer,
+      and charge a fee for, acceptance of support, warranty, indemnity,
+      or other liability obligations and/or rights consistent with this
+      License. However, in accepting such obligations, You may act only
+      on Your own behalf and on Your sole responsibility, not on behalf
+      of any other Contributor, and only if You agree to indemnify,
+      defend, and hold each Contributor harmless for any liability
+      incurred by, or claims asserted against, such Contributor by reason
+      of your accepting any such warranty or additional liability.
+
+   END OF TERMS AND CONDITIONS
+
+   APPENDIX: How to apply the Apache License to your work.
+
+      To apply the Apache License to your work, attach the following
+      boilerplate notice, with the fields enclosed by brackets "[]"
+      replaced with your own identifying information. (Don't include
+      the brackets!)  The text should be enclosed in the appropriate
+      comment syntax for the file format. We also recommend that a
+      file or class name and description of purpose be included on the
+      same "printed page" as the copyright notice for easier
+      identification within third-party archives.
+
+   Copyright [yyyy] [name of copyright owner]
+
+   Licensed under the Apache License, Version 2.0 (the "License");
+   you may not use this file except in compliance with the License.
+   You may obtain a copy of the License at
+
+       http://www.apache.org/licenses/LICENSE-2.0
+
+   Unless required by applicable law or agreed to in writing, software
+   distributed under the License is distributed on an "AS IS" BASIS,
+   WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+   See the License for the specific language governing permissions and
+   limitations under the License.

package/README.md

@@ -0,0 +1,125 @@
+# @geonosis/walk
+
+The customer walk as a gate. Nine computed-DOM probes over a list of URLs, one JSON report, and an
+exit code that tells a run that could not happen from a page that was clean.
+
+It exists because a screenshot lies. A cream chip on a cream page photographs exactly like a chip
+that is there; thirteen copies of one placeholder SVG photograph as thirteen icons; a full product
+page for a handle no backend has photographs as a product. The DOM does not lie, so every probe here
+reads computed styles, box geometry, asset signatures, rendered text and HTTP statuses — never
+pixels.
+
+```bash
+npm i -D @geonosis/walk playwright
+npx geonosis-walk https://example.test/ https://example.test/products/x --report walk.json
+```
+
+```
+0  the walk ran and found nothing
+1  the walk ran and found something
+2  the walk did not run — no browser, a URL that did not answer, a probe with no list to look for
+```
+
+Two is why there are three. A tool that answered "no findings" for a browser it could not launch
+would pass hardest exactly when it was broken.
+
+## The nine probes
+
+| id | What it reads | Needs |
+|---|---|---|
+| `light-on-light` | An element with an opaque background of its own, no background image, no border, no shadow, no outline, whose box does not simply repaint the one behind it — and whose WCAG contrast against the painted ancestor background is under the floor. | nothing (`minContrast` defaults to 1.05) |
+| `placeholder-asset` | Asset signatures: an image's resolved `src`, an SVG's own shape geometry. Fires on a signature used in more slots than allowed, and on any signature or `alt`/`aria-label`/`title` matching the placeholder list. | nothing (`maxRepeats` defaults to 2) |
+| `link-integrity` | `href` absent, empty, `#` or `javascript:` — and, for same-origin links, a HEAD (GET on 405/501) that answers 400 or worse. | nothing |
+| `fabricated-claim` | The page's rendered text, against a list of claim patterns. Not the markup: a claim in a comment is a claim nobody was shown. | **`claims`** |
+| `stub-only-entity` | An element naming an entity, offering a way to buy it, whose id is in no authoritative set. | **`known`** |
+| `fake-session` | Anything that means "signed in", on a page loaded with no cookies and no storage. | **`selectors` or `text`** |
+| `ops-leakage` | The rendered text of a scope, against patterns that name internal choices. Scope is what separates a leak from a footnote. | **`patterns`** |
+| `buy-box-above-fold` | `getBoundingClientRect()` at the walk's viewport: the buy box below the element it must precede, or below the fold. | **`selector`** |
+| `error-page-status` | A page whose rendered text matches an error-surface pattern, served with a healthy status. Every curl-style health check, uptime monitor and load balancer reads such a page as fine. | **`patterns`** |
+
+The six in bold **refuse the run** when the option is missing, naming it (D-031). None of the six
+can have a default that is true of a repo which has not configured it — what a company can stand
+behind, which entities exist, what its signed-in header looks like, which words mean "operations",
+where its buy box is, what its error surface says — and a probe that ran with an empty list would
+report a clean page for every repo that never set one up.
+
+## Configuration
+
+Everything lives in the `walk` block of `geonosis.json`; the command line wins where they overlap.
+
+```json
+{
+  "walk": {
+    "urls": ["http://localhost:3000/", "http://localhost:3000/products/kraft-mailer-box"],
+    "viewport": { "width": 1440, "height": 900 },
+    "report": ".geonosis/walk-report.json",
+    "probes": ["light-on-light", "placeholder-asset", "link-integrity", "fabricated-claim"],
+    "options": {
+      "fabricated-claim": { "claims": ["\\d\\.\\d/5", "\\d[\\d,]*\\+ brands", "\\d+M\\+"] },
+      "ops-leakage": { "scope": "[data-testid=delivery]", "patterns": ["Consolidated Sea"] },
+      "buy-box-above-fold": { "selector": "[data-testid=buy-box]", "above": "[data-testid=preview]" }
+    }
+  }
+}
+```
+
+```
+geonosis-walk [url…] [--report <path>] [--config <path>] [--viewport WIDTHxHEIGHT] [--probe <id>]…
+```
+
+With no `probes` the walk runs the three that need no list. A mobile pass is the same command with
+`--viewport 390x844`.
+
+## The report
+
+```json
+{
+  "startedAt": "…", "finishedAt": "…",
+  "viewport": { "width": 390, "height": 844 },
+  "probes": ["buy-box-above-fold"],
+  "counts": { "buy-box-above-fold": 1 },
+  "pages": [{ "url": "…", "findings": [
+    { "class": "buy-box-above-fold", "severity": "major", "url": "…",
+      "selector": "[data-testid=\"buy-box\"]",
+      "evidence": "the buy box starts at 900px, below the fold at 844px" }
+  ]}]
+}
+```
+
+`counts` is keyed by the classes that RAN, so a zero means "probed for, found none" and an absent
+class was never looked for. `@geonosis/ratchet`'s `walkFindings` counter reads this file and refuses
+when it is missing or unparsable, which is the same rule as the exit code: a gate that cannot
+measure has not passed.
+
+## Driving your own page
+
+`walk()` gives every URL a fresh, storage-free context — that is what makes `fake-session` mean
+anything. A surface behind a flow (a checkout with a cart in it) is not that shape, so drive your
+own page and call the probe:
+
+```ts
+import { probeById } from '@geonosis/walk'
+
+const response = await page.goto(url)
+
+const findings = await probeById('ops-leakage').run(page, {
+  memo: new Map(),
+  options: { patterns: ['Maersk Ocean'], scope: '[data-testid=delivery]' },
+  status: response?.status() ?? 0,
+  url: page.url(),
+  viewport: { width: 1440, height: 900 },
+})
+```
+
+`status` is the page's own response status, not a second request: `error-page-status` asks whether
+the status agrees with the body, and asking the server again asks a different question.
+
+## What this is not
+
+A green report is not a clean surface. Eight of the nine came from an audit that held 36 defects;
+four are reproduced by a probe alone, fourteen partially, and eighteen — five product tables that
+disagree, a cart that re-prices what the product page quoted, copy promising a control nobody built,
+four levels of taxonomy for fourteen products — are invisible to any browser probe there could be.
+Those stay the walker's judgement. The ninth came from a production incident instead, which is how
+the list is meant to grow. The reasoning, defect by defect, is in
+[`docs/walk-review-inventory-2026-08-30.md`](../../docs/walk-review-inventory-2026-08-30.md).

package/bin/geonosis-walk.mjs

@@ -0,0 +1,4 @@
+#!/usr/bin/env node
+// Committed, so `pnpm install` can link the bin on a fresh clone — before `pnpm build` has
+// produced dist/. A bin that only exists after a build is a bin that is missing when you need it.
+import '../dist/walk-cli.js'

package/dist/chunk-GA522TKR.js

@@ -0,0 +1,743 @@
+// src/types.ts
+var WalkError = class extends Error {
+  constructor(message) {
+    super(message);
+    this.name = "WalkError";
+  }
+};
+
+// src/browser.ts
+var inPage = (job) => {
+  const dom = {
+    /** The deepest element that still contains the match — the one a reader would point at. */
+    deepest: (root, needle) => {
+      let node = root;
+      let moved = true;
+      while (moved) {
+        moved = false;
+        for (const child of node.children) {
+          if (dom.textOf(child).includes(needle)) {
+            node = child;
+            moved = true;
+            break;
+          }
+        }
+      }
+      return node;
+    },
+    rectOf: (element) => {
+      const box = element.getBoundingClientRect();
+      return { height: box.height, left: box.left, top: box.top, width: box.width };
+    },
+    selectorOf: (element) => {
+      if (element.id !== "") return `#${element.id}`;
+      const testId = element.getAttribute("data-testid");
+      if (testId !== null && testId !== "") return `[data-testid="${testId}"]`;
+      const parts = [];
+      let node = element;
+      while (node !== null && parts.length < 5 && node.tagName !== "BODY") {
+        const parent = node.parentElement;
+        if (parent === null) break;
+        const current = node;
+        const siblings = [...parent.children].filter((one) => one.tagName === current.tagName);
+        const nth = siblings.indexOf(current) + 1;
+        const tag = current.tagName.toLowerCase();
+        parts.unshift(siblings.length > 1 ? `${tag}:nth-of-type(${nth})` : tag);
+        node = parent;
+      }
+      return parts.join(" > ");
+    },
+    shown: (element) => {
+      const box = element.getBoundingClientRect();
+      return box.width > 0 && box.height > 0 && getComputedStyle(element).visibility !== "hidden";
+    },
+    textOf: (element) => element.innerText ?? element.textContent ?? ""
+  };
+  if (job.kind === "contrast") {
+    const rgb = {
+      bordered: (style) => style.borderStyle !== "none" && [
+        style.borderTopWidth,
+        style.borderRightWidth,
+        style.borderBottomWidth,
+        style.borderLeftWidth
+      ].some((width) => Number.parseFloat(width) > 0),
+      channel: (value) => value / 255 <= 0.03928 ? value / 255 / 12.92 : ((value / 255 + 0.055) / 1.055) ** 2.4,
+      luminance: ({ b, g, r }) => 0.2126 * rgb.channel(r) + 0.7152 * rgb.channel(g) + 0.0722 * rgb.channel(b),
+      parse: (value) => {
+        const inside = /rgba?\(([^)]+)\)/.exec(value)?.[1];
+        if (inside === void 0) return null;
+        const numbers = inside.split(/[,\s/]+/).filter((one) => one !== "").map(Number);
+        const [r, g, b, a] = numbers;
+        if (r === void 0 || g === void 0 || b === void 0) return null;
+        return { a: a ?? 1, b, g, r };
+      },
+      ratio: (one, other) => {
+        const first = rgb.luminance(one);
+        const second = rgb.luminance(other);
+        return (Math.max(first, second) + 0.05) / (Math.min(first, second) + 0.05);
+      }
+    };
+    const hits = [];
+    const white = { a: 1, b: 255, g: 255, r: 255 };
+    for (const element of document.querySelectorAll(job.selector)) {
+      const tag = element.tagName;
+      if (tag === "HTML" || tag === "BODY") continue;
+      if (job.ignore.some((one) => element.matches(one))) continue;
+      const style = getComputedStyle(element);
+      const own = rgb.parse(style.backgroundColor);
+      if (own === null || own.a !== 1) continue;
+      if (style.backgroundImage !== "none" || style.boxShadow !== "none") continue;
+      if (style.outlineStyle !== "none" || rgb.bordered(style)) continue;
+      if (!dom.shown(element)) continue;
+      const box = element.getBoundingClientRect();
+      let node = element.parentElement;
+      let behind = null;
+      let fullBleed = false;
+      let behindSelector = "the canvas";
+      let behindValue = "rgb(255, 255, 255)";
+      while (node !== null) {
+        const parentStyle = getComputedStyle(node);
+        const colour = rgb.parse(parentStyle.backgroundColor);
+        if (colour !== null && colour.a === 1) {
+          const parentBox = node.getBoundingClientRect();
+          fullBleed = parentBox.width <= box.width && parentBox.height <= box.height;
+          behind = colour;
+          behindSelector = node.tagName === "BODY" ? "body" : dom.selectorOf(node);
+          behindValue = parentStyle.backgroundColor;
+          break;
+        }
+        node = node.parentElement;
+      }
+      if (fullBleed) continue;
+      const contrast = rgb.ratio(own, behind ?? white);
+      if (contrast >= job.minContrast) continue;
+      hits.push({
+        background: style.backgroundColor,
+        container: behindValue,
+        containerSelector: behindSelector,
+        contrast: Math.round(contrast * 100) / 100,
+        selector: dom.selectorOf(element)
+      });
+    }
+    return hits;
+  }
+  if (job.kind === "assets") {
+    const geometry = ["d", "points", "cx", "cy", "r", "x", "y", "x1", "y1", "x2", "y2", "href"];
+    const scope = document.querySelector(job.scope) ?? document.body;
+    const hits = [];
+    for (const element of scope.querySelectorAll(job.assetSelector)) {
+      if (!dom.shown(element)) continue;
+      const tag = element.tagName.toLowerCase();
+      const signature = tag === "img" ? `src:${element.src ?? element.getAttribute("src") ?? ""}` : `svg:${[
+        ...element.querySelectorAll("path,circle,rect,ellipse,line,polygon,polyline,use")
+      ].map(
+        (shape) => `${shape.tagName.toLowerCase()}(${geometry.map((name) => shape.getAttribute(name) ?? "").join(",")})`
+      ).join("|")}`;
+      hits.push({
+        label: [
+          element.getAttribute("alt") ?? "",
+          element.getAttribute("aria-label") ?? "",
+          element.getAttribute("title") ?? ""
+        ].filter((one) => one !== "").join(" "),
+        selector: dom.selectorOf(element),
+        signature
+      });
+    }
+    return hits;
+  }
+  if (job.kind === "links") {
+    return [...document.querySelectorAll(job.selector)].map((element) => ({
+      href: element.getAttribute("href"),
+      resolved: element.href ?? "",
+      selector: dom.selectorOf(element),
+      text: dom.textOf(element).trim().slice(0, 80)
+    }));
+  }
+  if (job.kind === "text") {
+    const roots = job.scope === "" ? [document.body] : [...document.querySelectorAll(job.scope)];
+    const hits = [];
+    for (const root of roots) {
+      const text = dom.textOf(root);
+      for (const pattern of job.patterns) {
+        const matcher = new RegExp(pattern, `${job.flags}g`);
+        let found = matcher.exec(text);
+        while (found !== null) {
+          const matched = found[0];
+          if (matched === "") break;
+          hits.push({
+            pattern,
+            selector: dom.selectorOf(dom.deepest(root, matched)),
+            text: matched
+          });
+          found = matcher.exec(text);
+        }
+      }
+    }
+    return hits;
+  }
+  if (job.kind === "entities") {
+    return [...document.querySelectorAll(job.selector)].map((element) => ({
+      affordance: job.affordance === "" || element.querySelector(job.affordance) !== null,
+      id: element.getAttribute(job.attribute) ?? "",
+      selector: dom.selectorOf(element)
+    }));
+  }
+  if (job.kind === "present") {
+    return job.selectors.map((selector) => ({
+      present: document.querySelector(selector) !== null,
+      selector
+    }));
+  }
+  return {
+    rects: job.selectors.map((selector) => {
+      const element = document.querySelector(selector);
+      return { rect: element === null ? null : dom.rectOf(element), selector };
+    }),
+    viewportHeight: innerHeight
+  };
+};
+var collect = async (page, job) => await page.evaluate(inPage, job);
+
+// src/options.ts
+var stringOption = (probe, options, name, fallback) => {
+  const value = options[name];
+  if (typeof value === "string" && value !== "") return value;
+  if (fallback !== void 0) return fallback;
+  throw new WalkError(`${probe}: needs a "${name}" in the walk options`);
+};
+var stringsOption = (options, name, fallback) => {
+  const value = options[name];
+  if (!Array.isArray(value)) return fallback;
+  return value.filter((one) => typeof one === "string");
+};
+var numberOption = (options, name, fallback) => {
+  const value = options[name];
+  return typeof value === "number" && Number.isFinite(value) ? value : fallback;
+};
+var flagOption = (options, name, fallback) => typeof options[name] === "boolean" ? options[name] : fallback;
+var requireStrings = (probe, options, name) => {
+  const value = stringsOption(options, name, []);
+  if (value.length === 0) {
+    throw new WalkError(`${probe}: needs a non-empty "${name}" in the walk options`);
+  }
+  return value;
+};
+var ALLOWED_FLAGS = /* @__PURE__ */ new Set(["i", "m", "s", "u"]);
+var patternFlags = (probe, options) => {
+  const flags = stringOption(probe, options, "flags", "");
+  for (const flag of flags) {
+    if (!ALLOWED_FLAGS.has(flag)) {
+      throw new WalkError(`${probe}: "${flags}" is not a set of regex flags (i, m, s, u)`);
+    }
+  }
+  return flags;
+};
+var assertPatterns = (probe, patterns, flags) => {
+  for (const pattern of patterns) {
+    try {
+      RegExp(pattern, `${flags}g`);
+    } catch {
+      throw new WalkError(`${probe}: "${pattern}" is not a regular expression`);
+    }
+  }
+};
+
+// src/probes/buy-box-above-fold.ts
+var buyBoxAboveFold = {
+  class: "buy-box-above-fold",
+  id: "buy-box-above-fold",
+  needs: (options) => {
+    stringOption("buy-box-above-fold", options, "selector");
+  },
+  run: async (page, { options, url }) => {
+    const selector = stringOption("buy-box-above-fold", options, "selector");
+    const above = stringOption("buy-box-above-fold", options, "above", "");
+    const { rects, viewportHeight } = await collect(page, {
+      kind: "geometry",
+      selectors: above === "" ? [selector] : [selector, above]
+    });
+    const buyBox = rects.find((one) => one.selector === selector)?.rect ?? null;
+    if (buyBox === null) {
+      return flagOption(options, "required", false) ? [
+        {
+          class: "buy-box-above-fold",
+          evidence: `no element matches "${selector}" on a page the walk requires one on`,
+          severity: "major",
+          url
+        }
+      ] : [];
+    }
+    const fold = numberOption(options, "maxTop", viewportHeight);
+    const other = above === "" ? null : rects.find((one) => one.selector === above)?.rect ?? null;
+    const found = [];
+    if (other !== null && buyBox.top > other.top) {
+      found.push({
+        class: "buy-box-above-fold",
+        evidence: `the buy box starts at ${Math.round(buyBox.top)}px, below "${above}" at ${Math.round(other.top)}px`,
+        selector,
+        severity: "major",
+        url
+      });
+    }
+    if (buyBox.top >= fold) {
+      found.push({
+        class: "buy-box-above-fold",
+        evidence: `the buy box starts at ${Math.round(buyBox.top)}px, below the fold at ${Math.round(fold)}px`,
+        selector,
+        severity: "major",
+        url
+      });
+    }
+    return found;
+  }
+};
+
+// src/probes/error-page-status.ts
+var errorPageStatus = {
+  class: "error-page-status",
+  id: "error-page-status",
+  needs: (options) => {
+    const patterns = requireStrings("error-page-status", options, "patterns");
+    assertPatterns("error-page-status", patterns, patternFlags("error-page-status", options));
+  },
+  run: async (page, { options, status, url }) => {
+    if (status >= numberOption(options, "honestFrom", 400)) return [];
+    const hits = await collect(page, {
+      flags: patternFlags("error-page-status", options),
+      kind: "text",
+      patterns: requireStrings("error-page-status", options, "patterns"),
+      scope: stringOption("error-page-status", options, "scope", "")
+    });
+    return hits.map((hit) => ({
+      class: "error-page-status",
+      evidence: `"${hit.text}" is on a page that answered ${status} \u2014 every health check reads that as healthy`,
+      selector: hit.selector,
+      severity: "blocking",
+      url
+    }));
+  }
+};
+
+// src/probes/fabricated-claim.ts
+var fabricatedClaim = {
+  class: "fabricated-claim",
+  id: "fabricated-claim",
+  needs: (options) => {
+    const claims = requireStrings("fabricated-claim", options, "claims");
+    assertPatterns("fabricated-claim", claims, patternFlags("fabricated-claim", options));
+  },
+  run: async (page, { options, url }) => {
+    const hits = await collect(page, {
+      flags: patternFlags("fabricated-claim", options),
+      kind: "text",
+      patterns: requireStrings("fabricated-claim", options, "claims"),
+      scope: stringOption("fabricated-claim", options, "scope", "")
+    });
+    return hits.map((hit) => ({
+      class: "fabricated-claim",
+      evidence: `"${hit.text}" is on the page, matching /${hit.pattern}/`,
+      selector: hit.selector,
+      severity: "blocking",
+      url
+    }));
+  }
+};
+
+// src/probes/fake-session.ts
+var escapeForRegex = (value) => value.replaceAll(/[.*+?^${}()|[\]\\]/g, "\\$&");
+var fakeSession = {
+  class: "fake-session",
+  id: "fake-session",
+  needs: (options) => {
+    const selectors = stringsOption(options, "selectors", []);
+    const text = stringsOption(options, "text", []);
+    if (selectors.length === 0 && text.length === 0) {
+      throw new WalkError(
+        'fake-session: needs "selectors" or "text" \u2014 what a signed-in page looks like here'
+      );
+    }
+  },
+  run: async (page, { options, url }) => {
+    const selectors = stringsOption(options, "selectors", []);
+    const text = stringsOption(options, "text", []);
+    const present = selectors.length === 0 ? [] : await collect(page, { kind: "present", selectors });
+    const said = text.length === 0 ? [] : await collect(page, {
+      flags: "",
+      kind: "text",
+      patterns: text.map(escapeForRegex),
+      scope: ""
+    });
+    const bySelector = present.filter((hit) => hit.present).map((hit) => ({
+      class: "fake-session",
+      evidence: `a context nobody signed in to renders ${hit.selector}`,
+      selector: hit.selector,
+      severity: "blocking",
+      url
+    }));
+    const byText = said.map((hit) => ({
+      class: "fake-session",
+      evidence: `a context nobody signed in to reads "${hit.text}"`,
+      selector: hit.selector,
+      severity: "blocking",
+      url
+    }));
+    return [...bySelector, ...byText];
+  }
+};
+
+// src/probes/light-on-light.ts
+var lightOnLight = {
+  class: "light-on-light",
+  id: "light-on-light",
+  run: async (page, { options, url }) => {
+    const minContrast = numberOption(options, "minContrast", 1.05);
+    const hits = await collect(page, {
+      ignore: stringsOption(options, "ignore", []),
+      kind: "contrast",
+      minContrast,
+      selector: stringOption("light-on-light", options, "selector", "*")
+    });
+    return hits.map((hit) => ({
+      class: "light-on-light",
+      evidence: `${hit.background} on ${hit.container} (${hit.containerSelector}) \u2014 contrast ${hit.contrast.toFixed(2)}, floor ${minContrast}`,
+      selector: hit.selector,
+      severity: "major",
+      url
+    }));
+  }
+};
+
+// src/probes/link-integrity.ts
+var DEAD = ["", "#"];
+var linkIntegrity = {
+  class: "link-integrity",
+  id: "link-integrity",
+  run: async (page, { memo, options, url }) => {
+    const dead = stringsOption(options, "deadHrefs", DEAD);
+    const ignore = stringsOption(options, "ignore", []);
+    const checkExternal = flagOption(options, "checkExternal", false);
+    const origin = new URL(url).origin;
+    const hits = await collect(page, {
+      kind: "links",
+      selector: stringOption("link-integrity", options, "selector", 'a,[role="link"]')
+    });
+    const found = [];
+    for (const hit of hits) {
+      const href = hit.href;
+      if (href === null || dead.includes(href.trim()) || href.trim().startsWith("javascript:")) {
+        found.push({
+          class: "link-integrity",
+          evidence: `dead control: href ${href === null ? "absent" : `"${href}"`} on "${hit.text}"`,
+          selector: hit.selector,
+          severity: "major",
+          url
+        });
+        continue;
+      }
+      const target = hit.resolved;
+      if (!target.startsWith("http")) continue;
+      if (ignore.some((pattern) => new RegExp(pattern).test(target))) continue;
+      if (!checkExternal && new URL(target).origin !== origin) continue;
+      const status = await statusOf(page, memo, target);
+      if (status < 400) continue;
+      found.push({
+        class: "link-integrity",
+        evidence: `${target} answered ${status}`,
+        selector: hit.selector,
+        severity: "blocking",
+        url
+      });
+    }
+    return found;
+  }
+};
+var statusOf = async (page, memo, target) => {
+  const key = `link-integrity:${target}`;
+  const seen = memo.get(key);
+  if (typeof seen === "number") return seen;
+  let status;
+  try {
+    const head = await page.request.head(target, { failOnStatusCode: false });
+    status = head.status() === 405 || head.status() === 501 ? (await page.request.get(target, { failOnStatusCode: false })).status() : head.status();
+  } catch (error) {
+    status = 599;
+    memo.set(`${key}:why`, error.message);
+  }
+  memo.set(key, status);
+  return status;
+};
+
+// src/probes/ops-leakage.ts
+var opsLeakage = {
+  class: "ops-leakage",
+  id: "ops-leakage",
+  needs: (options) => {
+    const patterns = requireStrings("ops-leakage", options, "patterns");
+    assertPatterns("ops-leakage", patterns, patternFlags("ops-leakage", options));
+  },
+  run: async (page, { options, url }) => {
+    const hits = await collect(page, {
+      flags: patternFlags("ops-leakage", options),
+      kind: "text",
+      patterns: requireStrings("ops-leakage", options, "patterns"),
+      scope: stringOption("ops-leakage", options, "scope", "")
+    });
+    return hits.map((hit) => ({
+      class: "ops-leakage",
+      evidence: `"${hit.text}" is offered to the customer, matching /${hit.pattern}/`,
+      selector: hit.selector,
+      severity: "blocking",
+      url
+    }));
+  }
+};
+
+// src/probes/placeholder-asset.ts
+var placeholderAsset = {
+  class: "placeholder-asset",
+  id: "placeholder-asset",
+  run: async (page, { options, url }) => {
+    const maxRepeats = numberOption(options, "maxRepeats", 2);
+    const signatures = stringsOption(options, "signatures", []);
+    const flags = patternFlags("placeholder-asset", options);
+    assertPatterns("placeholder-asset", signatures, flags);
+    const hits = await collect(page, {
+      assetSelector: stringOption("placeholder-asset", options, "assets", "img,svg"),
+      kind: "assets",
+      scope: stringOption("placeholder-asset", options, "scope", "body")
+    });
+    const named = hits.filter(
+      (hit) => signatures.some(
+        (pattern) => new RegExp(pattern, flags).test(`${hit.signature} ${hit.label}`)
+      )
+    ).map((hit) => ({
+      class: "placeholder-asset",
+      evidence: `asset matches a placeholder signature: ${hit.signature.slice(0, 120)}`,
+      selector: hit.selector,
+      severity: "major",
+      url
+    }));
+    const bySignature = /* @__PURE__ */ new Map();
+    for (const hit of hits) {
+      bySignature.set(hit.signature, [...bySignature.get(hit.signature) ?? [], hit.selector]);
+    }
+    const repeated = [...bySignature.entries()].filter(([, selectors]) => selectors.length > maxRepeats).map(([signature, selectors]) => ({
+      class: "placeholder-asset",
+      evidence: `the same asset in ${selectors.length} slots, more than the ${maxRepeats} allowed \u2014 ${signature.slice(0, 120)}`,
+      selector: selectors[0],
+      severity: "major",
+      url
+    }));
+    return [...named, ...repeated];
+  }
+};
+
+// src/probes/stub-only-entity.ts
+var stubOnlyEntity = {
+  class: "stub-only-entity",
+  id: "stub-only-entity",
+  needs: (options) => {
+    requireStrings("stub-only-entity", options, "known");
+  },
+  run: async (page, { options, url }) => {
+    const known = new Set(requireStrings("stub-only-entity", options, "known"));
+    const attribute = stringOption("stub-only-entity", options, "attribute", "data-entity-id");
+    const hits = await collect(page, {
+      affordance: stringOption("stub-only-entity", options, "affordance", ""),
+      attribute,
+      kind: "entities",
+      selector: stringOption("stub-only-entity", options, "selector", `[${attribute}]`)
+    });
+    return hits.filter((hit) => hit.id !== "" && hit.affordance && !known.has(hit.id)).map((hit) => ({
+      class: "stub-only-entity",
+      evidence: `"${hit.id}" can be bought here and is in no authoritative set of ${known.size} entities`,
+      selector: hit.selector,
+      severity: "blocking",
+      url
+    }));
+  }
+};
+
+// src/probes/index.ts
+var PROBES = [
+  buyBoxAboveFold,
+  errorPageStatus,
+  fabricatedClaim,
+  fakeSession,
+  lightOnLight,
+  linkIntegrity,
+  opsLeakage,
+  placeholderAsset,
+  stubOnlyEntity
+];
+var probeById = (id) => {
+  const probe = PROBES.find((one) => one.id === id);
+  if (probe === void 0) {
+    throw new Error(
+      `no probe called "${id}" \u2014 known probes: ${PROBES.map((one) => one.id).join(", ")}`
+    );
+  }
+  return probe;
+};
+var DEFAULT_PROBES = PROBES.filter((one) => one.needs === void 0);
+
+// src/config.ts
+import { existsSync, readFileSync } from "fs";
+import { resolve } from "path";
+var VIEWPORT = { height: 900, width: 1440 };
+var WALK_REPORT = ".geonosis/walk-report.json";
+var WALK_DEFAULT = {
+  options: {},
+  probes: DEFAULT_PROBES.map((one) => one.id),
+  report: WALK_REPORT,
+  urls: [],
+  viewport: VIEWPORT
+};
+var KNOWN = /* @__PURE__ */ new Set(["options", "probes", "report", "urls", "viewport"]);
+var isRecord = (value) => typeof value === "object" && value !== null && !Array.isArray(value);
+var readViewport = (value) => {
+  if (value === void 0) return VIEWPORT;
+  if (!isRecord(value) || typeof value.height !== "number" || typeof value.width !== "number") {
+    throw new WalkError('walk.viewport must be { "width": <number>, "height": <number> }');
+  }
+  return { height: value.height, width: value.width };
+};
+var parseViewport = (value) => {
+  const found = /^(\d+)x(\d+)$/.exec(value.trim());
+  if (found?.[1] === void 0 || found[2] === void 0) {
+    throw new WalkError(`"${value}" is not a viewport \u2014 write it as WIDTHxHEIGHT, e.g. 390x844`);
+  }
+  return { height: Number(found[2]), width: Number(found[1]) };
+};
+var readStrings = (value, name, fallback) => {
+  if (value === void 0) return fallback;
+  if (!Array.isArray(value) || value.some((one) => typeof one !== "string")) {
+    throw new WalkError(`walk.${name} must be a list of strings`);
+  }
+  return value;
+};
+var loadWalkConfig = (file) => {
+  if (!existsSync(file)) return WALK_DEFAULT;
+  let parsed;
+  try {
+    parsed = JSON.parse(readFileSync(file, "utf8"));
+  } catch (error) {
+    throw new WalkError(`${file} is not valid JSON: ${error.message}`);
+  }
+  if (!isRecord(parsed)) throw new WalkError(`${file} must hold an object`);
+  const block = parsed.walk;
+  if (block === void 0) return WALK_DEFAULT;
+  if (!isRecord(block)) throw new WalkError("walk must be an object");
+  for (const key of Object.keys(block)) {
+    if (!KNOWN.has(key)) throw new WalkError(`walk.${key} is not a key of the walk block`);
+  }
+  const options = block.options ?? {};
+  if (!isRecord(options)) throw new WalkError("walk.options must be an object keyed by probe id");
+  for (const [id, one] of Object.entries(options)) {
+    if (!isRecord(one)) throw new WalkError(`walk.options.${id} must be an object`);
+  }
+  return {
+    options,
+    probes: readStrings(block.probes, "probes", WALK_DEFAULT.probes),
+    report: typeof block.report === "string" ? block.report : WALK_REPORT,
+    urls: readStrings(block.urls, "urls", []),
+    viewport: readViewport(block.viewport)
+  };
+};
+var configPath = (cwd, given) => resolve(cwd, given ?? "geonosis.json");
+
+// src/walk.ts
+var launch = async () => {
+  let chromium;
+  try {
+    ;
+    ({ chromium } = await import("playwright"));
+  } catch (error) {
+    throw new WalkError(
+      `playwright is a peer dependency of @geonosis/walk and is not installed: ${error.message}`
+    );
+  }
+  try {
+    return await chromium.launch({ headless: true });
+  } catch (error) {
+    throw new WalkError(
+      `chromium would not launch \u2014 \`npx playwright install chromium\`: ${error.message}`
+    );
+  }
+};
+var walk = async ({
+  browser,
+  options = {},
+  probes,
+  urls,
+  viewport
+}) => {
+  if (urls.length === 0) throw new WalkError("no URL to walk");
+  for (const probe of probes) probe.needs?.(options[probe.id] ?? {});
+  const startedAt = (/* @__PURE__ */ new Date()).toISOString();
+  const own = browser ?? await launch();
+  const memo = /* @__PURE__ */ new Map();
+  const pages = [];
+  try {
+    for (const url of urls) {
+      const context = await own.newContext({ viewport });
+      try {
+        const page = await context.newPage();
+        const response = await page.goto(url).catch((error) => {
+          throw new WalkError(`${url} could not be opened: ${error.message}`);
+        });
+        if (response === null) throw new WalkError(`${url} answered nothing`);
+        if (response.status() >= 400) {
+          throw new WalkError(`${url} answered ${response.status()}`);
+        }
+        const findings = [];
+        for (const probe of probes) {
+          findings.push(
+            ...await probe.run(page, {
+              memo,
+              options: options[probe.id] ?? {},
+              status: response.status(),
+              url,
+              viewport
+            })
+          );
+        }
+        pages.push({ findings, url });
+      } finally {
+        await context.close();
+      }
+    }
+  } finally {
+    if (browser === void 0) await own.close();
+  }
+  const counts = {};
+  for (const probe of probes) counts[probe.class] = 0;
+  for (const page of pages) {
+    for (const finding of page.findings) {
+      counts[finding.class] = (counts[finding.class] ?? 0) + 1;
+    }
+  }
+  return {
+    counts,
+    finishedAt: (/* @__PURE__ */ new Date()).toISOString(),
+    pages,
+    probes: probes.map((one) => one.id),
+    startedAt,
+    viewport
+  };
+};
+var findingsIn = (report) => report.pages.reduce((total, page) => total + page.findings.length, 0);
+
+export {
+  WalkError,
+  PROBES,
+  probeById,
+  DEFAULT_PROBES,
+  WALK_REPORT,
+  WALK_DEFAULT,
+  parseViewport,
+  loadWalkConfig,
+  configPath,
+  walk,
+  findingsIn
+};

package/dist/index.d.ts

@@ -0,0 +1,137 @@
+import { Page, Browser } from 'playwright';
+
+/**
+ * The nine defect classes the walk is mechanical about.
+ *
+ * Six are the dielime CX audit's own groups; `light-on-light` is dielime's G3 browser-proof probe
+ * (a cream chip on a cream page reads as broken, and the screenshot says it is fine),
+ * `buy-box-above-fold` is that audit's G1 promoted to a class, and `error-page-status` came from a
+ * production incident: an error surface served with a 200, which every health check read as
+ * healthy. What the nine do NOT cover — a number that disagrees with a number on another page, copy
+ * that promises a control nobody built, four levels of taxonomy for fourteen products — is in
+ * `docs/walk-review-inventory-2026-08-30.md`, and stays the walker's judgement. A green walk report
+ * is not a clean surface.
+ */
+type DefectClass = 'buy-box-above-fold' | 'error-page-status' | 'fabricated-claim' | 'fake-session' | 'light-on-light' | 'link-integrity' | 'ops-leakage' | 'placeholder-asset' | 'stub-only-entity';
+/** `blocking` breaks trust or the buy path; `major` confuses the buyer; `minor` is polish. */
+type Severity = 'blocking' | 'major' | 'minor';
+/**
+ * One defect, as the build plan's contract states it. `evidence` is the measured value — the two
+ * colours and the ratio, the status code, the matched text — never a restatement of the class,
+ * because the reader's next question is always "what did you actually see".
+ */
+type Finding = {
+    class: DefectClass;
+    evidence: string;
+    selector?: string;
+    severity: Severity;
+    url: string;
+};
+type Viewport = {
+    height: number;
+    width: number;
+};
+type ProbeContext = {
+    /**
+     * One walk, one memo. `link-integrity` would otherwise send a HEAD request for the same footer
+     * link once per page, which is forty requests for one answer on a forty-page walk.
+     */
+    memo: Map<string, unknown>;
+    /** This probe's own block of the `options` map, already narrowed by id. */
+    options: Record<string, unknown>;
+    /**
+     * The status the page's OWN response carried. Read from `page.goto`, because nothing on a loaded
+     * page remembers it and a second request for it would ask a different question of a server that
+     * may not answer twice the same way.
+     */
+    status: number;
+    url: string;
+    viewport: Viewport;
+};
+type Probe = {
+    class: DefectClass;
+    id: string;
+    /**
+     * D-031, per probe: a probe that cannot mean anything without an option refuses the run when it
+     * is missing, naming the option. Five of the eight have one — a claim list, an authoritative id
+     * set, what "signed in" looks like, the operations patterns, the buy-box selector — because none
+     * of those five can have a default that is true of a repo that has not configured it. A probe
+     * that ran and reported nothing because nobody told it what to look for is indistinguishable
+     * from a clean page.
+     */
+    needs?: (options: Record<string, unknown>) => void;
+    run: (page: Page, context: ProbeContext) => Promise<Finding[]>;
+};
+type PageReport = {
+    findings: Finding[];
+    url: string;
+};
+type WalkReport = {
+    /**
+     * Keyed by the classes that RAN. A zero therefore means "probed for, none found"; a class that is
+     * absent was never looked for. All eight keys with five zeros would read as five clean gates
+     * nobody enabled.
+     */
+    counts: Partial<Record<DefectClass, number>>;
+    finishedAt: string;
+    pages: PageReport[];
+    probes: string[];
+    startedAt: string;
+    viewport: Viewport;
+};
+/**
+ * The walk could not run: no browser, no URL, a page that did not answer, a probe with no option it
+ * needs. Distinct from "the walk ran and found nothing", which is a report with zeros in it — the
+ * CLI turns this into exit 2 and that into exit 0.
+ */
+declare class WalkError extends Error {
+    constructor(message: string);
+}
+
+type WalkConfig = {
+    options: Record<string, Record<string, unknown>>;
+    probes: string[];
+    report: string;
+    urls: string[];
+    viewport: Viewport;
+};
+declare const WALK_REPORT = ".geonosis/walk-report.json";
+declare const WALK_DEFAULT: WalkConfig;
+/** `WxH`, the shape a viewport is written in everywhere else — 1440x900, 390x844. */
+declare const parseViewport: (value: string) => Viewport;
+/** The `walk` block of `geonosis.json`, every key optional, every default a contract. */
+declare const loadWalkConfig: (file: string) => WalkConfig;
+declare const configPath: (cwd: string, given?: string) => string;
+
+declare const PROBES: Probe[];
+declare const probeById: (id: string) => Probe;
+/**
+ * The probes a walk runs when nobody named any: the ones whose reading is a property of any page.
+ * The other five need a repo's own list to mean anything (D-031) and would refuse the run, so a
+ * default set that included them would make `geonosis-walk <url>` fail on every repo.
+ */
+declare const DEFAULT_PROBES: Probe[];
+
+type WalkInput = {
+    /** An already-open browser, for a walker driving a flow. Absent means launch one and close it. */
+    browser?: Browser;
+    /** Each probe's options, keyed by probe id. */
+    options?: Record<string, Record<string, unknown>>;
+    probes: Probe[];
+    urls: string[];
+    viewport: Viewport;
+};
+/**
+ * Every URL, every probe, one report.
+ *
+ * Each page gets its OWN context, with no cookies and no storage. That is what makes `fake-session`
+ * mean anything, and it is why `walk` is the stateless surface: a walker that has to reach a
+ * checkout with a cart in it drives its own page and calls `probe.run(page, context)` directly.
+ *
+ * Refusals come BEFORE the browser opens, and a page that did not answer stops the walk. A report
+ * with no findings in it must only ever mean the probes looked and found none.
+ */
+declare const walk: ({ browser, options, probes, urls, viewport, }: WalkInput) => Promise<WalkReport>;
+declare const findingsIn: (report: WalkReport) => number;
+
+export { DEFAULT_PROBES, type DefectClass, type Finding, PROBES, type PageReport, type Probe, type ProbeContext, type Severity, type Viewport, WALK_DEFAULT, WALK_REPORT, type WalkConfig, WalkError, type WalkInput, type WalkReport, configPath, findingsIn, loadWalkConfig, parseViewport, probeById, walk };

package/dist/index.js

@@ -0,0 +1,26 @@
+import {
+  DEFAULT_PROBES,
+  PROBES,
+  WALK_DEFAULT,
+  WALK_REPORT,
+  WalkError,
+  configPath,
+  findingsIn,
+  loadWalkConfig,
+  parseViewport,
+  probeById,
+  walk
+} from "./chunk-GA522TKR.js";
+export {
+  DEFAULT_PROBES,
+  PROBES,
+  WALK_DEFAULT,
+  WALK_REPORT,
+  WalkError,
+  configPath,
+  findingsIn,
+  loadWalkConfig,
+  parseViewport,
+  probeById,
+  walk
+};

package/dist/walk-cli.js

@@ -0,0 +1,78 @@
+import {
+  WalkError,
+  configPath,
+  findingsIn,
+  loadWalkConfig,
+  parseViewport,
+  probeById,
+  walk
+} from "./chunk-GA522TKR.js";
+
+// src/walk-cli.ts
+import { mkdirSync, writeFileSync } from "fs";
+import { dirname, resolve } from "path";
+var parse = (argv) => {
+  const out = { probes: [], urls: [] };
+  for (let at = 0; at < argv.length; at += 1) {
+    const arg = argv[at];
+    if (arg === void 0) continue;
+    const takes = (name) => {
+      const value = argv[at + 1];
+      if (value === void 0) throw new WalkError(`${name} needs a value`);
+      at += 1;
+      return value;
+    };
+    if (arg === "--config") out.config = takes("--config");
+    else if (arg === "--report") out.report = takes("--report");
+    else if (arg === "--viewport") out.viewport = takes("--viewport");
+    else if (arg === "--probe") out.probes.push(takes("--probe"));
+    else if (arg.startsWith("-")) throw new WalkError(`unknown option ${arg}`);
+    else out.urls.push(arg);
+  }
+  return out;
+};
+var line = (finding) => `${finding.severity}  ${finding.class}  ${finding.url}${finding.selector === void 0 ? "" : `  ${finding.selector}`}
+    ${finding.evidence}`;
+var summarise = (report) => [
+  ...report.pages.flatMap((page) => page.findings.map(line)),
+  "",
+  ...Object.entries(report.counts).map(([name, count]) => `${count}  ${name}`),
+  `${report.pages.length} page(s), ${findingsIn(report)} finding(s)`
+].join("\n");
+var main = async () => {
+  const argv = parse(process.argv.slice(2));
+  const cwd = process.cwd();
+  const config = loadWalkConfig(configPath(cwd, argv.config));
+  const ids = argv.probes.length > 0 ? argv.probes : config.probes;
+  const probes = ids.map((id) => {
+    try {
+      return probeById(id);
+    } catch (error) {
+      throw new WalkError(error.message);
+    }
+  });
+  const report = await walk({
+    options: config.options,
+    probes,
+    urls: argv.urls.length > 0 ? argv.urls : config.urls,
+    viewport: argv.viewport === void 0 ? config.viewport : parseViewport(argv.viewport)
+  });
+  const at = resolve(cwd, argv.report ?? config.report);
+  mkdirSync(dirname(at), { recursive: true });
+  writeFileSync(at, `${JSON.stringify(report, null, 2)}
+`);
+  process.stdout.write(`${summarise(report)}
+${at}
+`);
+  return findingsIn(report) > 0 ? 1 : 0;
+};
+main().then(
+  (code) => {
+    process.exitCode = code;
+  },
+  (error) => {
+    process.stderr.write(`${error instanceof Error ? error.message : String(error)}
+`);
+    process.exitCode = 2;
+  }
+);

package/package.json

@@ -0,0 +1,49 @@
+{
+  "name": "@geonosis/walk",
+  "version": "1.0.0",
+  "description": "The customer walk as a gate: eight computed-DOM probes over a list of URLs, one JSON report, and an exit code that tells a could-not-run from a clean page.",
+  "keywords": [
+    "playwright",
+    "audit",
+    "accessibility",
+    "contrast",
+    "probe",
+    "gate",
+    "ci"
+  ],
+  "homepage": "https://github.com/microcompanies/geonosis/tree/main/packages/walk",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/microcompanies/geonosis.git",
+    "directory": "packages/walk"
+  },
+  "license": "Apache-2.0",
+  "type": "module",
+  "main": "dist/index.js",
+  "bin": {
+    "geonosis-walk": "bin/geonosis-walk.mjs"
+  },
+  "exports": {
+    ".": "./dist/index.js"
+  },
+  "files": [
+    "bin",
+    "dist"
+  ],
+  "peerDependencies": {
+    "playwright": ">=1.40.0"
+  },
+  "devDependencies": {
+    "playwright": "1.60.0"
+  },
+  "engines": {
+    "node": ">=22"
+  },
+  "publishConfig": {
+    "access": "public"
+  },
+  "scripts": {
+    "build": "tsup",
+    "typecheck": "tsc --noEmit"
+  }
+}