@molecule/app-e2e-fixtures-default 1.0.0

package/LICENSE

@@ -0,0 +1,115 @@
+                                 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.
+
+      "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.
+
+      "Contribution" shall mean any work of authorship, including the
+      original version of the Work and any modifications or additions
+      to that Work, that is intentionally submitted to the 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.
+
+      "Contributor" shall mean Licensor and any individual or Legal Entity
+      on behalf of whom a Contribution has been received by the 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
+      patent license to make, have made, use, offer to sell, sell, import,
+      and otherwise transfer the Work.
+
+   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.
+
+   5. Submission of Contributions.
+
+   6. Trademarks. This License does not grant permission to use the trade
+      names, trademarks, service marks, or product names of the Licensor.
+
+   7. Disclaimer of Warranty. Unless required by applicable law or
+      agreed to in writing, Licensor provides the Work on an "AS IS" BASIS,
+      WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND.
+
+   8. Limitation of Liability. In no event and under no legal theory shall
+      any Contributor be liable to You for damages.
+
+   9. Accepting Warranty or Additional Liability.
+
+   Copyright 2026 Molecule Dev, Inc.
+
+   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/dist/index.d.ts

@@ -0,0 +1,67 @@
+/**
+ * Shared Playwright `test` + `expect` with auto-attached browser
+ * console-error / pageerror guard.
+ *
+ * Every fleet app's e2e specs import `test` and `expect` from this
+ * module (re-exported through their per-app `_helpers.ts`) instead of
+ * `@playwright/test` directly. The custom `test` includes a
+ * `consoleGuard` fixture with `{ auto: true }`, so every test
+ * automatically subscribes to the browser's `pageerror` event and
+ * `console.error` messages, then asserts the buffer is empty at test
+ * teardown.
+ *
+ * This catches the failure mode where React (or any other client-side
+ * module) throws on mount but the spec only asserts against
+ * `page.request.get/post`, leaving the test green while the rendered
+ * page is blank. A single quill-delta ESM/CJS interop error sat for
+ * four days like this before we noticed — the replay videos were
+ * 17 KB of nothing and the JSON reported PASS.
+ *
+ * To intentionally let a known error through (rare — almost always a
+ * smell that should be fixed in the app), use
+ * `test.info().annotations.push({ type: 'allow-console-error', description: 'why' })`
+ * inside the test body BEFORE the error fires. The `description` is
+ * matched against the error text as a regular expression; if it is not
+ * a valid regex it is matched as a plain substring instead (so literal
+ * error text with `[`/`(` can be pasted verbatim). An annotation with
+ * no description allows every error — always provide one.
+ *
+ * A small, fixed set of browser-noise patterns are ALWAYS ignored regardless
+ * of `allow-console-error` (Vite HMR reconnect chatter, service-worker 404s
+ * in headless Chrome, and a real Chrome DevTools "failed to load SourceMap"
+ * message for any `https://`-hosted bundle — e.g. Stripe/Google Maps CDN
+ * scripts shipped without source maps). That last pattern is verified
+ * against the actual Chrome message text and constrained to `https://` so it
+ * can never silence a genuinely broken source map in the app's OWN bundle
+ * (served over plain `http://localhost` in dev/preview).
+ *
+ * @example
+ * ```ts
+ * // In fleet apps, the per-app `./_helpers.ts` re-exports these:
+ * import { test, expect } from '@molecule/app-e2e-fixtures-default'
+ *
+ * test('login lands on dashboard', async ({ page }) => {
+ *   await page.goto('/login')
+ *   await page.getByLabel(/email/i).fill('user@example.com')
+ *   // ...
+ * })
+ * ```
+ *
+ * @module
+ */
+import { expect } from '@playwright/test';
+interface ConsoleErrorEntry {
+    type: 'pageerror' | 'console.error';
+    text: string;
+    location?: string;
+}
+/**
+ * Custom Playwright `test` with an auto-attached browser console-error
+ * guard. Drop-in replacement for `import { test } from '@playwright/test'`.
+ */
+export declare const test: import("@playwright/test").TestType<import("@playwright/test").PlaywrightTestArgs & import("@playwright/test").PlaywrightTestOptions & {
+    consoleGuard: void;
+}, import("@playwright/test").PlaywrightWorkerArgs & import("@playwright/test").PlaywrightWorkerOptions>;
+export { expect };
+export type { ConsoleErrorEntry };
+//# sourceMappingURL=index.d.ts.map

package/dist/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAkDG;AAEH,OAAO,EAAuB,MAAM,EAAgB,MAAM,kBAAkB,CAAA;AAE5E,UAAU,iBAAiB;IACzB,IAAI,EAAE,WAAW,GAAG,eAAe,CAAA;IACnC,IAAI,EAAE,MAAM,CAAA;IACZ,QAAQ,CAAC,EAAE,MAAM,CAAA;CAClB;AAkCD;;;GAGG;AACH,eAAO,MAAM,IAAI;kBAA+B,IAAI;wGAkElD,CAAA;AAEF,OAAO,EAAE,MAAM,EAAE,CAAA;AACjB,YAAY,EAAE,iBAAiB,EAAE,CAAA"}

package/dist/index.js

@@ -0,0 +1,154 @@
+/**
+ * Shared Playwright `test` + `expect` with auto-attached browser
+ * console-error / pageerror guard.
+ *
+ * Every fleet app's e2e specs import `test` and `expect` from this
+ * module (re-exported through their per-app `_helpers.ts`) instead of
+ * `@playwright/test` directly. The custom `test` includes a
+ * `consoleGuard` fixture with `{ auto: true }`, so every test
+ * automatically subscribes to the browser's `pageerror` event and
+ * `console.error` messages, then asserts the buffer is empty at test
+ * teardown.
+ *
+ * This catches the failure mode where React (or any other client-side
+ * module) throws on mount but the spec only asserts against
+ * `page.request.get/post`, leaving the test green while the rendered
+ * page is blank. A single quill-delta ESM/CJS interop error sat for
+ * four days like this before we noticed — the replay videos were
+ * 17 KB of nothing and the JSON reported PASS.
+ *
+ * To intentionally let a known error through (rare — almost always a
+ * smell that should be fixed in the app), use
+ * `test.info().annotations.push({ type: 'allow-console-error', description: 'why' })`
+ * inside the test body BEFORE the error fires. The `description` is
+ * matched against the error text as a regular expression; if it is not
+ * a valid regex it is matched as a plain substring instead (so literal
+ * error text with `[`/`(` can be pasted verbatim). An annotation with
+ * no description allows every error — always provide one.
+ *
+ * A small, fixed set of browser-noise patterns are ALWAYS ignored regardless
+ * of `allow-console-error` (Vite HMR reconnect chatter, service-worker 404s
+ * in headless Chrome, and a real Chrome DevTools "failed to load SourceMap"
+ * message for any `https://`-hosted bundle — e.g. Stripe/Google Maps CDN
+ * scripts shipped without source maps). That last pattern is verified
+ * against the actual Chrome message text and constrained to `https://` so it
+ * can never silence a genuinely broken source map in the app's OWN bundle
+ * (served over plain `http://localhost` in dev/preview).
+ *
+ * @example
+ * ```ts
+ * // In fleet apps, the per-app `./_helpers.ts` re-exports these:
+ * import { test, expect } from '@molecule/app-e2e-fixtures-default'
+ *
+ * test('login lands on dashboard', async ({ page }) => {
+ *   await page.goto('/login')
+ *   await page.getByLabel(/email/i).fill('user@example.com')
+ *   // ...
+ * })
+ * ```
+ *
+ * @module
+ */
+import { expect, test as base } from '@playwright/test';
+/** Substrings that are always ignored — browser noise that doesn't reflect app bugs. */
+const ALWAYS_IGNORE = [
+    // Vite HMR dev-only websocket reconnect warnings — happen on the
+    // test runner's first poll before vite is fully booted; harmless.
+    /\[vite\].*connecting/i,
+    /\[vite\].*server connection lost/i,
+    // Service worker registration failures in headless Chrome — VitePWA
+    // tries to register at /sw.js but our smoke build emits to /workbox-*
+    // and Playwright fixtures the user-agent. Cosmetic.
+    /service worker.*404/i,
+    // Chrome DevTools' own probe for source maps on third-party CDN bundles
+    // we don't ship maps for (Stripe, Google Maps, etc). Two bugs fixed here,
+    // both verified against a headless Chromium probe + the real reported
+    // message text (not guessed): (1) the verb was wrong — real Chrome output
+    // is "DevTools failed to load SourceMap: Could not load content for
+    // <url>: ...", not "failed to fetch source map", so the old pattern never
+    // matched real Chrome text at all; (2) the host check (`.cdn.`) doesn't
+    // match real vendor hosts (js.stripe.com, maps.googleapis.com contain no
+    // '.cdn.' substring). Now matches any `https://`-hosted source map
+    // (third-party CDN bundles are always TLS; the app's own dev/preview
+    // server is plain `http://localhost`, so same-origin source-map issues
+    // are never accidentally silenced by this pattern).
+    // NOTE (verified, not assumed): a probe with a broken `sourceMappingURL`
+    // produced ZERO console messages via `page.on('console')` under plain
+    // Playwright automation (with and without tracing) — Chrome only fetches
+    // source maps when a DevTools Sources panel is actually attached, which a
+    // headless Playwright run never does. So this entry currently matches
+    // nothing observed in practice; it is defense-in-depth against a future
+    // Chrome/Playwright behavior change, not an active filter today.
+    /devtools failed to load source ?map.*https:\/\//i,
+];
+/**
+ * Custom Playwright `test` with an auto-attached browser console-error
+ * guard. Drop-in replacement for `import { test } from '@playwright/test'`.
+ */
+export const test = base.extend({
+    consoleGuard: [
+        async ({ page }, use, testInfo) => {
+            const buffer = [];
+            // Each allow-console-error description is tried as a regex; an invalid
+            // pattern (e.g. verbatim error text containing `[` or `(`) falls back to
+            // plain substring matching instead of throwing from inside the guard.
+            const matchesAllowed = (text, description) => {
+                if (description === undefined)
+                    return true; // no description = allow everything
+                try {
+                    return new RegExp(description).test(text);
+                }
+                catch (_error) {
+                    // Invalid regex — treat the description as a literal substring.
+                    return text.includes(description);
+                }
+            };
+            const shouldIgnore = (text) => {
+                if (ALWAYS_IGNORE.some((re) => re.test(text)))
+                    return true;
+                return testInfo.annotations
+                    .filter((a) => a.type === 'allow-console-error')
+                    .some((a) => matchesAllowed(text, a.description));
+            };
+            const onPageError = (err) => {
+                const text = err.message || String(err);
+                if (shouldIgnore(text))
+                    return;
+                buffer.push({ type: 'pageerror', text });
+            };
+            const onConsole = (msg) => {
+                if (msg.type() !== 'error')
+                    return;
+                const text = msg.text();
+                if (shouldIgnore(text))
+                    return;
+                const loc = msg.location();
+                buffer.push({
+                    type: 'console.error',
+                    text,
+                    location: loc?.url ? `${loc.url}:${loc.lineNumber}` : undefined,
+                });
+            };
+            page.on('pageerror', onPageError);
+            page.on('console', onConsole);
+            try {
+                await use();
+            }
+            finally {
+                page.off('pageerror', onPageError);
+                page.off('console', onConsole);
+            }
+            if (buffer.length > 0) {
+                const lines = buffer
+                    .map((e) => `  - [${e.type}] ${e.text}${e.location ? `  (${e.location})` : ''}`)
+                    .join('\n');
+                throw new Error(`Browser console error(s) during test (${buffer.length}):\n${lines}\n\n` +
+                    `If this error is genuinely expected, add\n` +
+                    `  test.info().annotations.push({ type: 'allow-console-error', description: '<regex>' })\n` +
+                    `to the test body BEFORE the error fires.`);
+            }
+        },
+        { auto: true },
+    ],
+});
+export { expect };

package/package.json

@@ -0,0 +1,49 @@
+{
+  "name": "@molecule/app-e2e-fixtures-default",
+  "version": "1.0.0",
+  "description": "Shared Playwright `test` + `expect` with auto-attached browser console-error/pageerror guard. Every fleet app's e2e specs import from here so a runtime exception (React mount failure, ESM/CJS interop error, unhandled rejection) hard-fails the test instead of silently passing.",
+  "type": "module",
+  "main": "dist/index.js",
+  "types": "dist/index.d.ts",
+  "scripts": {
+    "build": "tsc",
+    "test": "vitest run",
+    "test:watch": "vitest"
+  },
+  "exports": {
+    ".": {
+      "types": "./dist/index.d.ts",
+      "import": "./dist/index.js"
+    }
+  },
+  "files": [
+    "dist"
+  ],
+  "keywords": [
+    "molecule",
+    "playwright",
+    "e2e",
+    "fixtures",
+    "console-errors"
+  ],
+  "license": "Apache-2.0",
+  "devDependencies": {
+    "@playwright/test": "1.62.0",
+    "@types/node": "26.1.2",
+    "typescript": "6.0.3",
+    "vitest": "4.1.10"
+  },
+  "peerDependencies": {
+    "@playwright/test": "^1.50.0"
+  },
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/molecule-dev/molecule.git",
+    "directory": "packages/app/features/e2e-fixtures-default"
+  },
+  "homepage": "https://github.com/molecule-dev/molecule/tree/main/packages/app/features/e2e-fixtures-default",
+  "bugs": "https://github.com/molecule-dev/molecule/issues",
+  "publishConfig": {
+    "access": "public"
+  }
+}