@molecule/app-e2e-preview 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/README.md

@@ -0,0 +1,26 @@
+# @molecule/app-e2e-preview
+
+Drives the live IDE preview page as a Playwright-shaped page over a same-origin WebSocket through the dev server — no browser binary in the sandbox
+
+## Type
+
+`provider`
+
+## Implements
+
+`@molecule/app-e2e`
+
+## Injection Notes
+
+### Requirements
+
+- None
+
+### Post-Injection Steps
+
+- Run `npm install` to install dependencies
+- Run `npm run build` to compile
+
+### Known Limitations
+
+- None yet

package/dist/client.d.ts

@@ -0,0 +1,14 @@
+/**
+ * The page client: a small script the Vite plugin injects into every
+ * dev/preview document. It opens a same-origin WebSocket back to the hub,
+ * runs `evaluate` requests, navigates on request, relays viewport requests to
+ * the IDE that frames it, and forwards console output, errors and dialogs.
+ *
+ * Plain ES5-flavoured JavaScript in a string: it must run in whatever the
+ * previewed app runs in, and it must never depend on the app's bundler.
+ *
+ * @module
+ */
+/** The client script's source, ready to serve as `text/javascript`. */
+export declare const E2E_PREVIEW_CLIENT_SCRIPT: string;
+//# sourceMappingURL=client.d.ts.map

package/dist/client.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"client.d.ts","sourceRoot":"","sources":["../src/client.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;GAUG;AAIH,uEAAuE;AACvE,eAAO,MAAM,yBAAyB,QAmIrC,CAAA"}

package/dist/client.js

@@ -0,0 +1,146 @@
+/**
+ * The page client: a small script the Vite plugin injects into every
+ * dev/preview document. It opens a same-origin WebSocket back to the hub,
+ * runs `evaluate` requests, navigates on request, relays viewport requests to
+ * the IDE that frames it, and forwards console output, errors and dialogs.
+ *
+ * Plain ES5-flavoured JavaScript in a string: it must run in whatever the
+ * previewed app runs in, and it must never depend on the app's bundler.
+ *
+ * @module
+ */
+import { E2E_WS_PATH } from './types.js';
+/** The client script's source, ready to serve as `text/javascript`. */
+export const E2E_PREVIEW_CLIENT_SCRIPT = `;(function () {
+  if (window.__molE2EClient) return
+  var PATH = ${JSON.stringify(E2E_WS_PATH)}
+  var proto = location.protocol === 'https:' ? 'wss://' : 'ws://'
+  var pageId = (window.crypto && crypto.randomUUID) ? crypto.randomUUID() : String(Date.now()) + '-' + String(Math.random()).slice(2)
+  var ws = null
+  var backoff = 500
+  var leaving = false
+  var safe = function (value) {
+    if (value === undefined) return null
+    try {
+      return JSON.parse(JSON.stringify(value, function (k, v) { return typeof v === 'function' ? undefined : v }))
+    } catch (e) {
+      return String(value)
+    }
+  }
+  var send = function (obj) {
+    try { if (ws && ws.readyState === 1) ws.send(JSON.stringify(obj)) } catch (e) {}
+  }
+  var describe = function (args) {
+    var out = []
+    for (var i = 0; i < args.length; i++) {
+      var a = args[i]
+      if (typeof a === 'string') out.push(a)
+      else if (a instanceof Error) out.push(a.stack || a.message || String(a))
+      else { try { out.push(JSON.stringify(a)) } catch (e) { out.push(String(a)) } }
+    }
+    return out.join(' ')
+  }
+  var sameOrigin = function (url) {
+    var u = new URL(url, location.href)
+    if ((u.hostname === 'localhost' || u.hostname === '127.0.0.1' || u.hostname === '0.0.0.0') && u.host !== location.host) {
+      return location.origin + u.pathname + u.search + u.hash
+    }
+    return u.href
+  }
+  var handle = function (msg) {
+    var id = msg.id
+    var reply = function (obj) { obj.id = id; obj.href = location.href; send(obj) }
+    try {
+      if (msg.op === 'evaluate') {
+        var fn = new Function('return (' + msg.source + ')')()
+        Promise.resolve(fn(msg.arg)).then(function (value) {
+          reply({ ok: true, value: safe(value) })
+        }, function (e) {
+          reply({ ok: false, error: (e && e.stack) || String(e) })
+        })
+      } else if (msg.op === 'goto') {
+        var target = sameOrigin(msg.url)
+        reply({ ok: true, navigating: true, target: target })
+        leaving = true
+        if (target === location.href) location.reload()
+        else location.assign(target)
+      } else if (msg.op === 'reload') {
+        reply({ ok: true, navigating: true })
+        leaving = true
+        location.reload()
+      } else if (msg.op === 'history') {
+        reply({ ok: true, navigating: true })
+        history.go(msg.delta)
+      } else if (msg.op === 'viewport') {
+        try { window.parent.postMessage({ type: 'molecule:viewport', id: id, width: msg.width, height: msg.height }, '*') } catch (e) {}
+        var started = Date.now()
+        var check = function () {
+          if (Math.abs(innerWidth - msg.width) <= 2 || Date.now() - started > 1500) {
+            reply({ ok: true, value: { width: innerWidth, height: innerHeight, framed: window.parent !== window } })
+          } else setTimeout(check, 50)
+        }
+        setTimeout(check, 50)
+      } else if (msg.op === 'ping') {
+        reply({ ok: true, value: 'pong' })
+      } else {
+        reply({ ok: false, error: 'unknown op: ' + msg.op })
+      }
+    } catch (e) {
+      reply({ ok: false, error: (e && e.stack) || String(e) })
+    }
+  }
+  var hello = function () {
+    send({ hello: true, id: pageId, href: location.href, title: document.title, readyState: document.readyState, innerWidth: innerWidth, innerHeight: innerHeight, hidden: document.hidden, framed: window.parent !== window })
+  }
+  var connect = function () {
+    if (leaving) return
+    try { ws = new WebSocket(proto + location.host + PATH + '?role=page&id=' + encodeURIComponent(pageId)) } catch (e) { setTimeout(connect, backoff); return }
+    ws.onopen = function () { backoff = 500; hello() }
+    ws.onmessage = function (ev) {
+      var msg = null
+      try { msg = JSON.parse(ev.data) } catch (e) { return }
+      if (msg && msg.op) handle(msg)
+    }
+    ws.onclose = function () { if (!leaving) { backoff = Math.min(backoff * 2, 5000); setTimeout(connect, backoff) } }
+    ws.onerror = function () {}
+  }
+  var levels = ['log', 'info', 'warn', 'error', 'debug']
+  for (var i = 0; i < levels.length; i++) (function (level) {
+    var orig = console[level]
+    console[level] = function () {
+      try { send({ event: 'console', type: level === 'warn' ? 'warning' : level, text: describe(arguments) }) } catch (e) {}
+      return orig && orig.apply(console, arguments)
+    }
+  })(levels[i])
+  window.addEventListener('error', function (e) {
+    send({ event: 'pageerror', message: (e.error && e.error.message) || e.message || 'Error', stack: e.error && e.error.stack, url: e.filename, lineNumber: e.lineno, columnNumber: e.colno })
+  })
+  window.addEventListener('unhandledrejection', function (e) {
+    var r = e.reason
+    send({ event: 'pageerror', message: (r && r.message) || String(r), stack: r && r.stack })
+  })
+  var dialogs = ['alert', 'confirm', 'prompt']
+  for (var d = 0; d < dialogs.length; d++) (function (kind) {
+    window[kind] = function (message, defaultValue) {
+      send({ event: 'dialog', type: kind, message: String(message === undefined ? '' : message), defaultValue: defaultValue === undefined ? '' : String(defaultValue) })
+      if (kind === 'confirm') return true
+      if (kind === 'prompt') return defaultValue === undefined ? '' : String(defaultValue)
+      return undefined
+    }
+  })(dialogs[d])
+  var navigated = function () { send({ event: 'navigated', href: location.href, title: document.title }) }
+  window.addEventListener('popstate', navigated)
+  window.addEventListener('hashchange', navigated)
+  var wrapHistory = function (name) {
+    var orig = history[name]
+    history[name] = function () { var r = orig.apply(this, arguments); setTimeout(navigated, 0); return r }
+  }
+  wrapHistory('pushState')
+  wrapHistory('replaceState')
+  document.addEventListener('visibilitychange', function () { send({ event: 'visibility', hidden: document.hidden, href: location.href }) })
+  window.addEventListener('pagehide', function () { leaving = true; try { if (ws) ws.close() } catch (e) {} })
+  window.__molE2EClient = { pageId: pageId, version: 1 }
+  connect()
+})()
+`;
+//# sourceMappingURL=client.js.map

package/dist/client.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"client.js","sourceRoot":"","sources":["../src/client.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;GAUG;AAEH,OAAO,EAAE,WAAW,EAAE,MAAM,YAAY,CAAA;AAExC,uEAAuE;AACvE,MAAM,CAAC,MAAM,yBAAyB,GAAG;;eAE1B,IAAI,CAAC,SAAS,CAAC,WAAW,CAAC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAiIzC,CAAA"}

package/dist/index.d.ts

@@ -0,0 +1,77 @@
+/**
+ * E2E bond that drives the LIVE PREVIEW — the page the molecule.dev IDE is
+ * already showing, in the person's own browser — as a Playwright-shaped page.
+ * No browser binary in the sandbox, nothing to download: the browser that
+ * renders the preview is the browser that runs the test.
+ *
+ * Three small parts:
+ *
+ * 1. A Vite plugin ({@link molE2EPreviewPlugin}) every scaffolded app carries.
+ *    In `vite` dev and `vite preview` it serves a tiny page client, injects it
+ *    into each document, and attaches a WebSocket hub to the dev server.
+ *    `vite build` output is untouched.
+ * 2. The page client, which opens a same-origin WebSocket back to that hub
+ *    (through whatever proxy serves the preview), runs `evaluate` requests,
+ *    navigates on request, asks the framing IDE to resize on
+ *    `setViewportSize`, and forwards console output, errors and dialogs.
+ * 3. The driver ({@link provider}), which the test runner uses from the same
+ *    machine as the dev server: it connects to the hub as `role=driver`
+ *    (loopback only, with the hub's token) and turns one connected page into
+ *    `@molecule/app-e2e`'s Playwright-shaped `Page`.
+ *
+ * @example
+ * ```ts
+ * // e2e/bonds.ts (scaffolded)
+ * import { resolveE2EProviderName, setProvider } from '@molecule/app-e2e'
+ * import { provider as playwright } from '@molecule/app-e2e-playwright'
+ * import { provider as preview } from '@molecule/app-e2e-preview'
+ *
+ * setProvider(resolveE2EProviderName() === 'preview' ? preview : playwright)
+ *
+ * // vite-preview-bridge-plugin.ts (scaffolded) — the plugin rides the existing molecule plugin
+ * import { molE2EPreviewPlugin } from '@molecule/app-e2e-preview/vite'
+ *
+ * // any script — measure the live page without a test runner
+ * import { connectPreview } from '@molecule/app-e2e-preview'
+ * const page = await connectPreview()
+ * await page.setViewportSize({ width: 390, height: 844 })
+ * console.log(await page.locator('article p').first().evaluate((el) => getComputedStyle(el).fontSize))
+ * await page.close()
+ * ```
+ *
+ * @remarks
+ * - **Someone must be looking.** The renderer is a browser tab showing the
+ *   preview. `connect()` waits (30s by default) for a page to be connected
+ *   and then fails with a message saying to open the preview in the IDE or
+ *   in any tab. Any connected viewer will do — a desktop tab keeps working
+ *   while a phone sleeps. The IDE holds a screen wake lock during builds and
+ *   re-delivers commands when a hidden tab wakes.
+ * - **Discovery.** The driver tries `MOL_E2E_PREVIEW_URL`, then ports
+ *   `MOL_E2E_PREVIEW_PORT`, 5173 (the sandbox preview port), `VITE_PORT`,
+ *   3000, reading each hub's token from `MOL_E2E_TOKEN` or the file the hub
+ *   writes in the OS temp dir. Only loopback drivers with the token are
+ *   accepted, so a preview URL never becomes a way to run code in someone
+ *   else's tab.
+ * - **URLs.** `page.goto('/path')` navigates the previewed page relative to
+ *   ITS origin; an absolute `http://localhost:<port>/path` is rewritten to the
+ *   same path there, so specs written for a local base URL run unchanged.
+ * - **Viewport.** `page.setViewportSize` posts `molecule:viewport` to the
+ *   framing IDE, which resizes the frame; in a plain tab the size cannot
+ *   change and the call throws (the configured project viewport is applied
+ *   with a warning instead of a failure).
+ * - **What is not here** is listed in `@molecule/app-e2e`'s docs — screenshots,
+ *   network interception, element handles, iframes — each method throws with
+ *   the alternative; `@molecule/app-e2e-playwright` runs the same spec with
+ *   real browsers when you need them.
+ * - Imported (non-Vite) apps get the hub only if their dev server can host
+ *   it; today the plugin covers every Vite-served app, which is every
+ *   molecule scaffold.
+ *
+ * @module
+ */
+export { E2E_PREVIEW_CLIENT_SCRIPT } from './client.js';
+export { connectPreview, listPreviewPages, provider } from './provider.js';
+export { attachE2EHub, type E2EHub } from './server.js';
+export * from './types.js';
+export { injectE2EClientTag, molE2EPreviewPlugin, type MolE2EPreviewPluginOptions } from './vite.js';
+//# 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;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAsEG;AAEH,OAAO,EAAE,yBAAyB,EAAE,MAAM,aAAa,CAAA;AACvD,OAAO,EAAE,cAAc,EAAE,gBAAgB,EAAE,QAAQ,EAAE,MAAM,eAAe,CAAA;AAC1E,OAAO,EAAE,YAAY,EAAE,KAAK,MAAM,EAAE,MAAM,aAAa,CAAA;AACvD,cAAc,YAAY,CAAA;AAC1B,OAAO,EAAE,kBAAkB,EAAE,mBAAmB,EAAE,KAAK,0BAA0B,EAAE,MAAM,WAAW,CAAA"}

package/dist/index.js

@@ -0,0 +1,77 @@
+/**
+ * E2E bond that drives the LIVE PREVIEW — the page the molecule.dev IDE is
+ * already showing, in the person's own browser — as a Playwright-shaped page.
+ * No browser binary in the sandbox, nothing to download: the browser that
+ * renders the preview is the browser that runs the test.
+ *
+ * Three small parts:
+ *
+ * 1. A Vite plugin ({@link molE2EPreviewPlugin}) every scaffolded app carries.
+ *    In `vite` dev and `vite preview` it serves a tiny page client, injects it
+ *    into each document, and attaches a WebSocket hub to the dev server.
+ *    `vite build` output is untouched.
+ * 2. The page client, which opens a same-origin WebSocket back to that hub
+ *    (through whatever proxy serves the preview), runs `evaluate` requests,
+ *    navigates on request, asks the framing IDE to resize on
+ *    `setViewportSize`, and forwards console output, errors and dialogs.
+ * 3. The driver ({@link provider}), which the test runner uses from the same
+ *    machine as the dev server: it connects to the hub as `role=driver`
+ *    (loopback only, with the hub's token) and turns one connected page into
+ *    `@molecule/app-e2e`'s Playwright-shaped `Page`.
+ *
+ * @example
+ * ```ts
+ * // e2e/bonds.ts (scaffolded)
+ * import { resolveE2EProviderName, setProvider } from '@molecule/app-e2e'
+ * import { provider as playwright } from '@molecule/app-e2e-playwright'
+ * import { provider as preview } from '@molecule/app-e2e-preview'
+ *
+ * setProvider(resolveE2EProviderName() === 'preview' ? preview : playwright)
+ *
+ * // vite-preview-bridge-plugin.ts (scaffolded) — the plugin rides the existing molecule plugin
+ * import { molE2EPreviewPlugin } from '@molecule/app-e2e-preview/vite'
+ *
+ * // any script — measure the live page without a test runner
+ * import { connectPreview } from '@molecule/app-e2e-preview'
+ * const page = await connectPreview()
+ * await page.setViewportSize({ width: 390, height: 844 })
+ * console.log(await page.locator('article p').first().evaluate((el) => getComputedStyle(el).fontSize))
+ * await page.close()
+ * ```
+ *
+ * @remarks
+ * - **Someone must be looking.** The renderer is a browser tab showing the
+ *   preview. `connect()` waits (30s by default) for a page to be connected
+ *   and then fails with a message saying to open the preview in the IDE or
+ *   in any tab. Any connected viewer will do — a desktop tab keeps working
+ *   while a phone sleeps. The IDE holds a screen wake lock during builds and
+ *   re-delivers commands when a hidden tab wakes.
+ * - **Discovery.** The driver tries `MOL_E2E_PREVIEW_URL`, then ports
+ *   `MOL_E2E_PREVIEW_PORT`, 5173 (the sandbox preview port), `VITE_PORT`,
+ *   3000, reading each hub's token from `MOL_E2E_TOKEN` or the file the hub
+ *   writes in the OS temp dir. Only loopback drivers with the token are
+ *   accepted, so a preview URL never becomes a way to run code in someone
+ *   else's tab.
+ * - **URLs.** `page.goto('/path')` navigates the previewed page relative to
+ *   ITS origin; an absolute `http://localhost:<port>/path` is rewritten to the
+ *   same path there, so specs written for a local base URL run unchanged.
+ * - **Viewport.** `page.setViewportSize` posts `molecule:viewport` to the
+ *   framing IDE, which resizes the frame; in a plain tab the size cannot
+ *   change and the call throws (the configured project viewport is applied
+ *   with a warning instead of a failure).
+ * - **What is not here** is listed in `@molecule/app-e2e`'s docs — screenshots,
+ *   network interception, element handles, iframes — each method throws with
+ *   the alternative; `@molecule/app-e2e-playwright` runs the same spec with
+ *   real browsers when you need them.
+ * - Imported (non-Vite) apps get the hub only if their dev server can host
+ *   it; today the plugin covers every Vite-served app, which is every
+ *   molecule scaffold.
+ *
+ * @module
+ */
+export { E2E_PREVIEW_CLIENT_SCRIPT } from './client.js';
+export { connectPreview, listPreviewPages, provider } from './provider.js';
+export { attachE2EHub } from './server.js';
+export * from './types.js';
+export { injectE2EClientTag, molE2EPreviewPlugin } from './vite.js';
+//# sourceMappingURL=index.js.map

package/dist/index.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.js","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAsEG;AAEH,OAAO,EAAE,yBAAyB,EAAE,MAAM,aAAa,CAAA;AACvD,OAAO,EAAE,cAAc,EAAE,gBAAgB,EAAE,QAAQ,EAAE,MAAM,eAAe,CAAA;AAC1E,OAAO,EAAE,YAAY,EAAe,MAAM,aAAa,CAAA;AACvD,cAAc,YAAY,CAAA;AAC1B,OAAO,EAAE,kBAAkB,EAAE,mBAAmB,EAAmC,MAAM,WAAW,CAAA"}

package/dist/provider.d.ts

@@ -0,0 +1,17 @@
+/**
+ * The driver: connects to the hub from inside the sandbox (or any machine
+ * running the dev server), picks a connected preview page, and exposes it as
+ * an `E2ETransport` for the core's `createEvaluatePage()`.
+ *
+ * @module
+ */
+import type { Page } from '@playwright/test';
+import { type E2EProvider } from '@molecule/app-e2e';
+import { type PagePeer, type PreviewConnectOptions } from './types.js';
+/** The bond: `setProvider(provider)` in your `e2e/bonds.ts`. */
+export declare const provider: E2EProvider;
+/** Open the live preview as a Playwright-shaped page from any script (`node scripts/check.mjs`). */
+export declare const connectPreview: (options?: PreviewConnectOptions) => Promise<Page>;
+/** The preview pages currently connected to the hub. */
+export declare const listPreviewPages: (options?: PreviewConnectOptions) => Promise<PagePeer[]>;
+//# sourceMappingURL=provider.d.ts.map

package/dist/provider.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"provider.d.ts","sourceRoot":"","sources":["../src/provider.ts"],"names":[],"mappings":"AAAA;;;;;;GAMG;AAMH,OAAO,KAAK,EAAE,IAAI,EAAE,MAAM,kBAAkB,CAAA;AAG5C,OAAO,EAGL,KAAK,WAAW,EAIjB,MAAM,mBAAmB,CAAA;AAG1B,OAAO,EAGL,KAAK,QAAQ,EACb,KAAK,qBAAqB,EAE3B,MAAM,YAAY,CAAA;AAkanB,gEAAgE;AAChE,eAAO,MAAM,QAAQ,EAAE,WAMtB,CAAA;AAED,oGAAoG;AACpG,eAAO,MAAM,cAAc,GAAI,UAAS,qBAA0B,KAAG,OAAO,CAAC,IAAI,CACtD,CAAA;AAE3B,wDAAwD;AACxD,eAAO,MAAM,gBAAgB,GAC3B,UAAS,qBAA0B,KAClC,OAAO,CAAC,QAAQ,EAAE,CAQpB,CAAA"}