@lensmcp/vite-plugin 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,80 @@
+# @lensmcp/vite-plugin
+
+> The single Vite plugin that makes a frontend app observable by [LensMCP](https://github.com/kiwiapps-ltd/lensmcp).
+
+LensMCP is an observability lens for coding agents. `@lensmcp/vite-plugin` is how a Vite-based frontend opts into that lens: add it to your `vite.config.ts` and your app starts streaming React renders, Valtio state changes, console output, network calls, route changes, runtime errors, and build events back to LensMCP — with no other source changes.
+
+Under the hood the plugin does three things: it aliases `valtio` to the instrumented drop-in [`@lensmcp/valtio-instrumentation`](https://www.npmjs.com/package/@lensmcp/valtio-instrumentation), it applies the [`@lensmcp/react-instrumentation`](https://www.npmjs.com/package/@lensmcp/react-instrumentation) Babel source transform to your JSX/TSX, and it injects a browser event bridge (a client runtime) that ships captured events to the lens over a local WebSocket. The plugin is **passive** — it never mutates your app's state or behaviour — and is meant to run in dev only.
+
+## Install
+
+```bash
+yarn add -D @lensmcp/vite-plugin
+```
+
+`vite` is a peer dependency (`^5 || ^6 || ^7 || ^8`).
+
+## Usage
+
+Add `lensmcpVitePlugin()` to your `plugins` array. Zero config is the intended path — every capability is on by default:
+
+```ts
+// vite.config.ts
+import { defineConfig } from 'vite';
+import react from '@vitejs/plugin-react';
+import { lensmcpVitePlugin } from '@lensmcp/vite-plugin';
+
+export default defineConfig({
+  plugins: [
+    react(),
+    lensmcpVitePlugin(),
+  ],
+});
+```
+
+The plugin runs at `enforce: 'pre'`, so its source transform sees raw JSX/TSX before `@vitejs/plugin-react` (Babel), `@vitejs/plugin-react@6` (oxc), or `@vitejs/plugin-react-swc` (SWC) turn JSX into calls — it coexists with whichever React compiler you use.
+
+To keep it dev-only, gate it on the command:
+
+```ts
+export default defineConfig(({ command }) => ({
+  plugins: [
+    react(),
+    lensmcpVitePlugin({ enabled: command === 'serve' }),
+  ],
+}));
+```
+
+## What it does
+
+- **`valtio` → `@lensmcp/valtio-instrumentation` alias.** A `config()` hook rewrites bare `import … from 'valtio'` to the instrumented drop-in, so existing Valtio stores become observable without edits. The alias uses an exact `/^valtio$/` match so the drop-in's own `valtio/vanilla` and `valtio/react` imports are left untouched. (Toggle with `aliasValtio`.)
+- **`@lensmcp/react-instrumentation` Babel transform.** A `transform()` hook runs the LensMCP Babel plugin (`lensmcpBabelPlugin`) over every `.jsx`/`.tsx` file outside `node_modules`, wrapping the app root, instrumenting hooks, and stamping JSX identity props. The output is plain JSX/TSX that downstream React compilers preserve. (Toggle with `transformSource`.)
+- **Browser event bridge / client runtime injection.** `transformIndexHtml()` injects `<script type="module" src="/@lensmcp/client-runtime">` into the page head; the plugin resolves that virtual module to a small client runtime. The runtime opens a WebSocket back to the plugin and forwards browser events — runtime errors, unhandled rejections, `console.*`, `fetch`, History/route changes, plus the pre-formed `publish` envelopes from the in-page React and Valtio instrumentation (via `window.__LENSMCP_PUBLISH__`). Each tab gets a stable per-tab id so multiple tabs stay distinct.
+- **Build + HMR events.** `handleHotUpdate()` emits an HMR event with the affected files, and `generateBundle()` emits a bundle-size report (per-chunk and per-module byte sizes). Vite's native `vite:error` stream is forwarded too.
+
+Incoming browser envelopes and Vite/Rollup events are normalised into LensMCP's `BaseEvent` shape and published. When an in-process `EventBus` is bound the plugin publishes directly; otherwise it forwards events cross-process over the same env-configured sink as the NestJS instrumentation — `LENSMCP_EVENT_FILE`, `LENSMCP_UDS`, or `LENSMCP_IPC_SOCKET` (`host:port`) — falling back to `console.debug` only for error-severity events when no sink is set.
+
+## Options
+
+`lensmcpVitePlugin(options?)` accepts `LensmcpViteOptions` — all fields are optional:
+
+| Option | Type | Default | Description |
+| --- | --- | --- | --- |
+| `enabled` | `boolean` | `true` | Whether the plugin attaches anything. Set `false` for production. |
+| `wsPort` | `number` | ephemeral | WebSocket port the client runtime posts events to. An unused port is chosen automatically when omitted. |
+| `wsHost` | `string` | `'127.0.0.1'` | Bind address for the WebSocket. |
+| `injectClient` | `boolean` | `true` | Inject the client runtime via a `<script>` tag. |
+| `aliasValtio` | `boolean` | `true` | Alias `valtio` to the instrumented drop-in in dev. |
+| `transformSource` | `boolean` | `true` | Run the LensMCP source transform (root-wrap + hooks + JSX ids). |
+
+The returned plugin also exposes a `wsPort(): number \| undefined` accessor (`LensmcpViteRuntime`), available after Vite's `configureServer` hook fires.
+
+## How it fits
+
+`@lensmcp/vite-plugin` is the front door for the browser-side of LensMCP. It pulls in [`@lensmcp/react-instrumentation`](https://www.npmjs.com/package/@lensmcp/react-instrumentation) (the Babel transform) and [`@lensmcp/valtio-instrumentation`](https://www.npmjs.com/package/@lensmcp/valtio-instrumentation) (the Valtio drop-in), then injects the bridge that those instrumentation layers publish through. The bridge ships the resulting events to the LensMCP runtime, where the gateway / MCP server collect and reduce them into resources (`react://`, `valtio://`, `runtime://browser/*`, `browser://tabs`) that a coding agent can query through the lens.
+
+You typically add this one plugin to a frontend app, pair it with the NestJS instrumentation on the backend, and the agent sees both sides of the running system.
+
+---
+
+Part of [LensMCP](https://github.com/kiwiapps-ltd/lensmcp). Apache-2.0.

package/index.d.ts

@@ -0,0 +1,4 @@
+export { lensmcpVitePlugin, handleClientEnvelope } from './lib/plugin.js';
+export type { LensmcpViteOptions, LensmcpViteRuntime, ClientEnvelope } from './lib/types.js';
+export { envelopeToEvent } from './lib/event-mappers.js';
+//# sourceMappingURL=index.d.ts.map

package/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,iBAAiB,EAAE,oBAAoB,EAAE,MAAM,iBAAiB,CAAC;AAC1E,YAAY,EAAE,kBAAkB,EAAE,kBAAkB,EAAE,cAAc,EAAE,MAAM,gBAAgB,CAAC;AAC7F,OAAO,EAAE,eAAe,EAAE,MAAM,wBAAwB,CAAC"}

package/index.js

@@ -0,0 +1,2 @@
+export { lensmcpVitePlugin, handleClientEnvelope } from './lib/plugin.js';
+export { envelopeToEvent } from './lib/event-mappers.js';

package/lib/event-mappers.d.ts

@@ -0,0 +1,10 @@
+import type { BaseEvent } from '@lensmcp/protocol-types';
+import type { ClientEnvelope } from './types.js';
+/**
+ * Translate a single client-runtime envelope into the normalised
+ * `BaseEvent` consumed by the LensMCP event bus. The Vite plugin
+ * publishes these; reducers in `@lensmcp/<app>` materialise them into
+ * `runtime://browser/*` resources.
+ */
+export declare function envelopeToEvent(env: ClientEnvelope, sessionId?: string): BaseEvent;
+//# sourceMappingURL=event-mappers.d.ts.map

package/lib/event-mappers.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"event-mappers.d.ts","sourceRoot":"","sources":["../../src/lib/event-mappers.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,yBAAyB,CAAC;AAEzD,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,YAAY,CAAC;AAIjD;;;;;GAKG;AACH,wBAAgB,eAAe,CAAC,GAAG,EAAE,cAAc,EAAE,SAAS,SAAyB,GAAG,SAAS,CAuIlG"}

package/lib/event-mappers.js

@@ -0,0 +1,169 @@
+import { fingerprint, ulid } from '@lensmcp/core';
+const SESSION_ID_PLACEHOLDER = 'pending';
+/**
+ * Translate a single client-runtime envelope into the normalised
+ * `BaseEvent` consumed by the LensMCP event bus. The Vite plugin
+ * publishes these; reducers in `@lensmcp/<app>` materialise them into
+ * `runtime://browser/*` resources.
+ */
+export function envelopeToEvent(env, sessionId = SESSION_ID_PLACEHOLDER) {
+    // Per-tab identity stamped by the client runtime — keys browser://tabs.
+    const tab = env.tabId ? { tabId: env.tabId } : {};
+    switch (env.kind) {
+        case 'error':
+            return {
+                id: ulid(),
+                sessionId,
+                timestamp: env.at,
+                source: 'client-runtime',
+                category: 'runtime',
+                severity: 'error',
+                context: { sessionId, ...tab },
+                fingerprint: fingerprint({
+                    kind: 'runtime',
+                    identity: `error:${normaliseStackTopFrame(env.stack)}`,
+                    file: env.source,
+                    detail: env.message,
+                }),
+                title: env.message,
+                message: env.stack ?? env.message,
+                location: env.source
+                    ? { file: env.source, line: env.lineno, column: env.colno }
+                    : undefined,
+                raw: env,
+            };
+        case 'unhandledrejection':
+            return {
+                id: ulid(),
+                sessionId,
+                timestamp: env.at,
+                source: 'client-runtime',
+                category: 'runtime',
+                severity: 'error',
+                context: { sessionId, ...tab },
+                fingerprint: fingerprint({
+                    kind: 'runtime',
+                    identity: `unhandledrejection:${env.reason.slice(0, 80)}`,
+                }),
+                title: 'Unhandled promise rejection',
+                message: env.reason,
+                raw: env,
+            };
+        case 'console': {
+            const severity = env.level === 'error' ? 'error' : env.level === 'warn' ? 'warning' : 'info';
+            const text = env.args.map(stringify).join(' ');
+            return {
+                id: ulid(),
+                sessionId,
+                timestamp: env.at,
+                source: 'client-runtime',
+                category: 'runtime',
+                severity,
+                context: { sessionId, ...tab },
+                fingerprint: fingerprint({
+                    kind: 'runtime',
+                    identity: `console:${env.level}:${text.slice(0, 80)}`,
+                }),
+                title: `console.${env.level}`,
+                message: text,
+                raw: env,
+            };
+        }
+        case 'fetch': {
+            const failed = env.error !== undefined || (env.status !== undefined && env.status >= 400);
+            return {
+                id: ulid(),
+                sessionId,
+                timestamp: env.at,
+                source: 'client-runtime',
+                category: 'network',
+                severity: failed ? 'error' : 'info',
+                context: { sessionId, ...tab },
+                fingerprint: fingerprint({
+                    kind: 'network',
+                    identity: `${env.method}:${normaliseUrl(env.url)}:${env.status ?? 'err'}`,
+                }),
+                title: `${env.method} ${env.url}${env.status !== undefined ? ` → ${env.status}` : ''}`,
+                message: env.error,
+                relatedUrls: [env.url],
+                raw: env,
+            };
+        }
+        case 'route':
+            return {
+                id: ulid(),
+                sessionId,
+                timestamp: env.at,
+                source: 'client-runtime',
+                category: 'runtime',
+                severity: 'info',
+                context: { sessionId, url: env.url, ...tab },
+                fingerprint: fingerprint({ kind: 'runtime', identity: `route:${env.url}` }),
+                title: `Route → ${env.url}`,
+                raw: env,
+            };
+        case 'ready':
+            return {
+                id: ulid(),
+                sessionId,
+                timestamp: env.at,
+                source: 'client-runtime',
+                category: 'runtime',
+                severity: 'info',
+                context: { sessionId, url: env.url, ...tab },
+                fingerprint: fingerprint({ kind: 'runtime', identity: 'client-ready' }),
+                title: 'Client runtime ready',
+                message: env.userAgent,
+                raw: env,
+            };
+        case 'publish':
+            // Pre-formed publish envelope from in-page instrumentation. Trust
+            // its source/category (the producer is our own injected code); the
+            // reducers gate on those, and the context carries the flow id so
+            // React renders correlate with the originating user action.
+            return {
+                id: ulid(),
+                sessionId,
+                timestamp: env.at,
+                source: env.source,
+                category: env.category,
+                severity: (env.severity ?? 'info'),
+                context: { sessionId, ...tab, ...(env.context ?? {}) },
+                fingerprint: env.fingerprint ?? fingerprint({ kind: 'publish', identity: env.title }),
+                title: env.title,
+                message: env.message,
+                raw: env.raw,
+            };
+    }
+}
+// --- helpers ---
+function normaliseStackTopFrame(stack) {
+    if (!stack)
+        return 'unknown';
+    const lines = stack.split('\n').slice(0, 2);
+    for (const line of lines) {
+        const m = line.match(/at\s+(\S+)/);
+        if (m && m[1])
+            return m[1];
+    }
+    return 'unknown';
+}
+function normaliseUrl(url) {
+    try {
+        const u = new URL(url, 'http://x');
+        return `${u.pathname}`;
+    }
+    catch {
+        return url;
+    }
+}
+function stringify(v) {
+    if (typeof v === 'string')
+        return v;
+    try {
+        return JSON.stringify(v);
+    }
+    catch {
+        return String(v);
+    }
+}

package/lib/plugin.d.ts

@@ -0,0 +1,36 @@
+import type { Plugin } from 'vite';
+import { type EventBus } from '@lensmcp/core';
+import type { LensmcpViteOptions, LensmcpViteRuntime } from './types.js';
+interface BoundDeps {
+    /**
+     * EventBus to publish onto (in-process, e.g. tests). If undefined, events are
+     * forwarded cross-process via the env sink — `LENSMCP_EVENT_FILE` / `LENSMCP_UDS`
+     * / `LENSMCP_IPC_SOCKET` (the same contract as the NestJS sink); console.debug
+     * is only the last-resort fallback for error-severity events when no sink is set.
+     */
+    bus?: EventBus;
+    /** Session id stamped onto each event. */
+    sessionId?: string;
+}
+/**
+ * Vite plugin that:
+ *   1. Stands up a tiny WebSocket so the injected @lensmcp/client-runtime
+ *      can post browser events back into the LensMCP event bus.
+ *   2. Injects a `<script type="module" src="/@lensmcp/client-runtime">`
+ *      into served HTML.
+ *   3. Resolves that virtual module to the bundled client runtime
+ *      (during Phase 1 — a minimal inline implementation; the real
+ *      package import lands in Phase 2/3).
+ *   4. Emits HMR + module-graph events for the build reducer.
+ *
+ * The plugin is *passive*: it never mutates app state or behaviour.
+ */
+export declare function lensmcpVitePlugin(options?: LensmcpViteOptions, deps?: BoundDeps): Plugin & LensmcpViteRuntime;
+/**
+ * Parse one raw WebSocket message from the injected client runtime and
+ * publish the resulting event. Exported so it can be exercised over a
+ * real WebSocket without booting Vite (see the react-bridge smoke).
+ */
+export declare function handleClientEnvelope(raw: string, deps: BoundDeps): void;
+export {};
+//# sourceMappingURL=plugin.d.ts.map

package/lib/plugin.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"plugin.d.ts","sourceRoot":"","sources":["../../src/lib/plugin.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,MAAM,EAAiB,MAAM,MAAM,CAAC;AAMlD,OAAO,EAAqB,KAAK,QAAQ,EAAE,MAAM,eAAe,CAAC;AACjE,OAAO,KAAK,EAAE,kBAAkB,EAAE,kBAAkB,EAAkB,MAAM,YAAY,CAAC;AAMzF,UAAU,SAAS;IACjB;;;;;OAKG;IACH,GAAG,CAAC,EAAE,QAAQ,CAAC;IACf,0CAA0C;IAC1C,SAAS,CAAC,EAAE,MAAM,CAAC;CACpB;AAED;;;;;;;;;;;;GAYG;AACH,wBAAgB,iBAAiB,CAC/B,OAAO,GAAE,kBAAuB,EAChC,IAAI,GAAE,SAAc,GACnB,MAAM,GAAG,kBAAkB,CA+K7B;AAqCD;;;;GAIG;AACH,wBAAgB,oBAAoB,CAAC,GAAG,EAAE,MAAM,EAAE,IAAI,EAAE,SAAS,GAAG,IAAI,CASvE"}

package/lib/plugin.js

@@ -0,0 +1,514 @@
+import { createServer as createNetServer, connect } from 'node:net';
+import { createSocket } from 'node:dgram';
+import { appendFileSync } from 'node:fs';
+import { WebSocketServer } from 'ws';
+import { fingerprint, ulid } from '@lensmcp/core';
+import { envelopeToEvent } from './event-mappers.js';
+const CLIENT_VIRTUAL_ID = '/@lensmcp/client-runtime';
+const RESOLVED_CLIENT_VIRTUAL_ID = '\0lensmcp-client-runtime';
+/**
+ * Vite plugin that:
+ *   1. Stands up a tiny WebSocket so the injected @lensmcp/client-runtime
+ *      can post browser events back into the LensMCP event bus.
+ *   2. Injects a `<script type="module" src="/@lensmcp/client-runtime">`
+ *      into served HTML.
+ *   3. Resolves that virtual module to the bundled client runtime
+ *      (during Phase 1 — a minimal inline implementation; the real
+ *      package import lands in Phase 2/3).
+ *   4. Emits HMR + module-graph events for the build reducer.
+ *
+ * The plugin is *passive*: it never mutates app state or behaviour.
+ */
+export function lensmcpVitePlugin(options = {}, deps = {}) {
+    const enabled = options.enabled ?? true;
+    const wsHost = options.wsHost ?? '127.0.0.1';
+    const injectClient = options.injectClient ?? true;
+    let wssPort;
+    let wss;
+    const aliasValtio = options.aliasValtio ?? true;
+    const transformSource = options.transformSource ?? true;
+    return {
+        name: '@lensmcp/vite-plugin',
+        apply: enabled ? undefined : () => false,
+        enforce: 'pre',
+        wsPort: () => wssPort,
+        config() {
+            if (!enabled || !aliasValtio)
+                return;
+            // Zero-config (Phase 8): make `import { proxy } from 'valtio'`
+            // resolve to the instrumented drop-in, so existing Valtio code
+            // becomes observable without edits. Dev-only.
+            //
+            // EXACT match (`/^valtio$/`) only — a bare-string alias does prefix
+            // matching, which would also rewrite the drop-in's own
+            // `valtio/vanilla` + `valtio/react` imports and self-loop.
+            return {
+                resolve: {
+                    alias: [
+                        { find: /^valtio$/, replacement: '@lensmcp/valtio-instrumentation' },
+                    ],
+                },
+            };
+        },
+        async configureServer(server) {
+            if (!enabled)
+                return;
+            const port = options.wsPort ?? (await findFreePort());
+            wssPort = port;
+            wss = new WebSocketServer({ host: wsHost, port });
+            wss.on('connection', (socket) => {
+                socket.on('message', (raw) => {
+                    handleClientEnvelope(raw.toString(), deps);
+                });
+            });
+            // Vite native error stream → our bus.
+            server.ws.on('vite:error', (data) => {
+                publish(deps, viteErrorToEvent(data, deps.sessionId));
+            });
+        },
+        resolveId(id) {
+            if (id === CLIENT_VIRTUAL_ID)
+                return RESOLVED_CLIENT_VIRTUAL_ID;
+            return null;
+        },
+        load(id) {
+            if (id !== RESOLVED_CLIENT_VIRTUAL_ID)
+                return null;
+            const port = wssPort ?? options.wsPort ?? 0;
+            return buildInlineClientRuntime({ host: wsHost, port });
+        },
+        // Zero-config source transform. Runs in our OWN transform hook at
+        // enforce:'pre', so it's independent of whichever compiler the React
+        // plugin uses — it runs on the raw JSX/TSX BEFORE @vitejs/plugin-react
+        // (Babel), @vitejs/plugin-react@6 (oxc, which dropped the `babel` hook)
+        // or @vitejs/plugin-react-swc (SWC) turn JSX into calls. The LensMCP
+        // output is plain JSX/TSX (LensmcpRoot/withFlow/traced* + data-* props),
+        // which every downstream compiler preserves (see swc-coexistence smoke).
+        // A native SWC/oxc rewrite would only be a perf optimisation.
+        async transform(code, id) {
+            if (!enabled || !transformSource)
+                return null;
+            const file = id.split('?')[0] ?? id;
+            if (file.includes('/node_modules/'))
+                return null;
+            if (!/\.[jt]sx$/.test(file))
+                return null;
+            const result = await runLensmcpBabel(code, file);
+            if (!result)
+                return null;
+            // Babel's source map is a valid Rollup map object at runtime; the
+            // cast just bridges the nominal type gap.
+            return { code: result.code, map: result.map };
+        },
+        transformIndexHtml() {
+            if (!injectClient || !enabled)
+                return;
+            return [
+                {
+                    tag: 'script',
+                    attrs: { type: 'module', src: CLIENT_VIRTUAL_ID },
+                    injectTo: 'head-prepend',
+                },
+            ];
+        },
+        handleHotUpdate(ctx) {
+            if (!enabled)
+                return;
+            const affected = ctx.modules
+                .map((m) => m.file ?? m.id ?? null)
+                .filter((f) => !!f);
+            publish(deps, {
+                id: ulid(),
+                sessionId: deps.sessionId ?? 'pending',
+                timestamp: Date.now(),
+                source: 'vite',
+                category: 'build',
+                severity: 'info',
+                context: { sessionId: deps.sessionId ?? 'pending' },
+                fingerprint: fingerprint({
+                    kind: 'hmr',
+                    identity: ctx.file,
+                }),
+                title: `HMR ${ctx.file}`,
+                relatedFiles: affected,
+            });
+        },
+        generateBundle(_opts, bundle) {
+            if (!enabled)
+                return;
+            const chunks = [];
+            let totalBytes = 0;
+            for (const file of Object.values(bundle)) {
+                const item = file;
+                const name = item.fileName;
+                let sizeBytes;
+                if (item.type === 'chunk') {
+                    sizeBytes = (item.code ?? '').length;
+                }
+                else {
+                    const src = item.source;
+                    sizeBytes =
+                        typeof src === 'string' ? src.length : src instanceof Uint8Array ? src.byteLength : 0;
+                }
+                totalBytes += sizeBytes;
+                const modules = [];
+                if (item.type === 'chunk' && item.modules) {
+                    for (const [id, mod] of Object.entries(item.modules)) {
+                        const ml = mod.renderedLength ?? mod.originalLength ?? 0;
+                        modules.push({ id, sizeBytes: ml });
+                    }
+                    modules.sort((a, b) => b.sizeBytes - a.sizeBytes);
+                }
+                chunks.push({ name, sizeBytes, modules });
+            }
+            const report = { timestamp: Date.now(), totalBytes, chunks };
+            publish(deps, {
+                id: ulid(),
+                sessionId: deps.sessionId ?? 'pending',
+                timestamp: Date.now(),
+                source: 'rollup',
+                category: 'build',
+                severity: 'info',
+                context: { sessionId: deps.sessionId ?? 'pending' },
+                fingerprint: fingerprint({ kind: 'bundle', identity: 'report' }),
+                title: `Bundle report: ${chunks.length} chunks, ${totalBytes} bytes`,
+                raw: { kind: 'bundle-report', report },
+            });
+        },
+        async closeBundle() {
+            if (wss) {
+                await new Promise((res) => wss?.close(() => res()));
+            }
+        },
+    };
+}
+// --- helpers ---
+/**
+ * Run the LensMCP Babel transform on one module's source. Lazily loads
+ * `@babel/core` + the plugin so they're only touched in dev when a
+ * `.jsx`/`.tsx` file is transformed. Returns null on parse error (let
+ * Vite proceed with the untransformed source).
+ */
+async function runLensmcpBabel(code, filename) {
+    try {
+        const [{ transformSync }, { lensmcpBabelPlugin }] = await Promise.all([
+            import('@babel/core'),
+            import('@lensmcp/react-instrumentation'),
+        ]);
+        const result = transformSync(code, {
+            filename,
+            babelrc: false,
+            configFile: false,
+            sourceMaps: true,
+            parserOpts: { plugins: ['jsx', 'typescript'] },
+            plugins: [[lensmcpBabelPlugin, { rootDir: process.cwd(), production: false }]],
+            code: true,
+        });
+        if (!result?.code)
+            return null;
+        return { code: result.code, map: result.map };
+    }
+    catch {
+        return null;
+    }
+}
+/**
+ * Parse one raw WebSocket message from the injected client runtime and
+ * publish the resulting event. Exported so it can be exercised over a
+ * real WebSocket without booting Vite (see the react-bridge smoke).
+ */
+export function handleClientEnvelope(raw, deps) {
+    let env;
+    try {
+        env = JSON.parse(raw);
+    }
+    catch {
+        return; // ignore malformed
+    }
+    if (!env || typeof env !== 'object' || !('kind' in env))
+        return;
+    publish(deps, envelopeToEvent(env, deps.sessionId));
+}
+function publish(deps, event) {
+    if (deps.bus) {
+        deps.bus.publish(event);
+        return;
+    }
+    // Cross-process: the MCP server runs in a separate process during
+    // `agent-dev`, so when no in-process bus is bound we forward events
+    // over the same transport the NestJS sink uses (resolved from env).
+    // The server's `startEventIngest` republishes them onto its bus.
+    const sink = resolveEnvSink();
+    if (sink) {
+        sink(event);
+        return;
+    }
+    if (event.severity === 'error' || event.severity === 'fatal') {
+        // Standalone fallback so the plugin is debuggable without a bus.
+        console.debug(`[lensmcp-vite] ${event.severity}: ${event.title}`);
+    }
+}
+let cachedEnvSink;
+/**
+ * Resolve a cross-process event sink from env, mirroring
+ * `@lensmcp/nest-instrumentation`'s `defaultEventSink`:
+ *   1. `LENSMCP_EVENT_FILE` — append one JSON line per event.
+ *   2. `LENSMCP_UDS` — Unix domain socket, framed NDJSON, reconnecting.
+ *   3. `LENSMCP_IPC_SOCKET` (`host:port`) — one UDP datagram per event.
+ * Cached after first resolution; returns null when none is set.
+ */
+function resolveEnvSink() {
+    if (cachedEnvSink !== undefined)
+        return cachedEnvSink;
+    const filePath = process.env['LENSMCP_EVENT_FILE'];
+    if (filePath) {
+        cachedEnvSink = (event) => {
+            try {
+                appendFileSync(filePath, JSON.stringify(event) + '\n');
+            }
+            catch {
+                /* swallow */
+            }
+        };
+        return cachedEnvSink;
+    }
+    const udsPath = process.env['LENSMCP_UDS'];
+    if (udsPath) {
+        cachedEnvSink = udsEnvSink(udsPath);
+        return cachedEnvSink;
+    }
+    const socketPath = process.env['LENSMCP_IPC_SOCKET'];
+    if (socketPath) {
+        const [host, portStr] = socketPath.split(':');
+        const port = Number(portStr);
+        if (host && Number.isFinite(port)) {
+            const sock = createSocket('udp4');
+            sock.unref();
+            cachedEnvSink = (event) => {
+                try {
+                    const buf = Buffer.from(JSON.stringify(event));
+                    sock.send(buf, port, host, () => undefined);
+                }
+                catch {
+                    /* swallow */
+                }
+            };
+            return cachedEnvSink;
+        }
+    }
+    cachedEnvSink = null;
+    return null;
+}
+/** Reconnecting NDJSON client over a Unix domain socket (see session/uds.ts). */
+function udsEnvSink(path) {
+    const queue = [];
+    let sock = null;
+    let connecting = false;
+    const flush = () => {
+        if (!sock || !sock.writable)
+            return;
+        while (queue.length > 0)
+            sock.write(queue.shift());
+    };
+    const open = () => {
+        if (connecting || sock)
+            return;
+        connecting = true;
+        const s = connect(path);
+        s.on('connect', () => {
+            connecting = false;
+            sock = s;
+            flush();
+        });
+        s.on('drain', flush);
+        s.on('error', () => {
+            connecting = false;
+            sock = null;
+        });
+        s.on('close', () => {
+            sock = null;
+        });
+        s.unref();
+    };
+    open();
+    return (event) => {
+        queue.push(JSON.stringify(event) + '\n');
+        while (queue.length > 10000)
+            queue.shift();
+        if (sock && sock.writable) {
+            flush();
+            return;
+        }
+        // Dead socket (server restart) — drop it so open() reconnects.
+        if (sock) {
+            try {
+                sock.destroy();
+            }
+            catch {
+                /* ignore */
+            }
+            sock = null;
+        }
+        open();
+    };
+}
+function viteErrorToEvent(data, sessionId) {
+    const message = data.err?.message ?? 'Vite error';
+    const stack = data.err?.stack;
+    return {
+        id: ulid(),
+        sessionId: sessionId ?? 'pending',
+        timestamp: Date.now(),
+        source: 'vite',
+        category: 'build',
+        severity: 'error',
+        context: { sessionId: sessionId ?? 'pending' },
+        fingerprint: fingerprint({ kind: 'vite', identity: data.type ?? message }),
+        title: message,
+        message: stack,
+    };
+}
+function findFreePort() {
+    return new Promise((resolve, reject) => {
+        const s = createNetServer();
+        s.unref();
+        s.on('error', reject);
+        s.listen(0, () => {
+            const addr = s.address();
+            if (!addr) {
+                s.close();
+                reject(new Error('Could not allocate free port'));
+                return;
+            }
+            const port = addr.port;
+            s.close(() => resolve(port));
+        });
+    });
+}
+/**
+ * Minimal browser-side runtime that mirrors what `@lensmcp/client-runtime`
+ * will eventually own. Inlined here so Phase 1 has no cross-build
+ * coupling. Future: replace with a real import of the published
+ * package's browser bundle.
+ */
+function buildInlineClientRuntime(opts) {
+    return `// @lensmcp/client-runtime (inlined by @lensmcp/vite-plugin)
+(() => {
+  if (typeof window === 'undefined') return;
+  if (window.__LENSMCP_CLIENT__) return;
+  window.__LENSMCP_CLIENT__ = true;
+
+  const WS_URL = 'ws://${opts.host}:${opts.port}';
+  let ws = null;
+  let queue = [];
+  let openOnce = false;
+
+  // Per-TAB identity: sessionStorage is scoped to the tab (and survives
+  // reloads in it), so each browser tab gets a stable id — this is what
+  // lets browser://tabs show every open tab instead of one 'default'.
+  const TAB_ID = (() => {
+    try {
+      let t = sessionStorage.getItem('lensmcp:tabId');
+      if (!t) { t = 'tab-' + Math.random().toString(36).slice(2, 10); sessionStorage.setItem('lensmcp:tabId', t); }
+      return t;
+    } catch (e) { return 'tab-' + Math.random().toString(36).slice(2, 10); }
+  })();
+
+  function send(env) {
+    env.at = Date.now();
+    env.tabId = TAB_ID;
+    if (ws && ws.readyState === 1) ws.send(JSON.stringify(env));
+    else queue.push(env);
+  }
+  function open() {
+    try { ws = new WebSocket(WS_URL); } catch (e) { setTimeout(open, 1000); return; }
+    ws.addEventListener('open', () => {
+      openOnce = true;
+      while (queue.length) { try { ws.send(JSON.stringify(queue.shift())); } catch {} }
+      send({ kind: 'ready', userAgent: navigator.userAgent, url: location.href });
+    });
+    ws.addEventListener('close', () => { if (openOnce) setTimeout(open, 1000); });
+    ws.addEventListener('error', () => { /* ignore — close handler reconnects */ });
+  }
+  open();
+
+  // Bridge for in-page instrumentation (@lensmcp/react-instrumentation,
+  // @lensmcp/valtio-instrumentation). Their publish() calls land here and
+  // ride the same WS as a 'publish' envelope, so React renders + Valtio
+  // updates reach react:// / valtio://.
+  window.__LENSMCP_PUBLISH__ = (envelope) => {
+    try {
+      send({
+        kind: 'publish',
+        source: envelope.source,
+        category: envelope.category,
+        severity: envelope.severity,
+        title: envelope.title,
+        message: envelope.message,
+        fingerprint: envelope.fingerprint,
+        context: envelope.context,
+        raw: envelope.raw,
+      });
+    } catch {}
+  };
+
+  // Errors
+  window.addEventListener('error', (e) => {
+    send({
+      kind: 'error',
+      message: e.message,
+      stack: e.error && e.error.stack,
+      source: e.filename,
+      lineno: e.lineno,
+      colno: e.colno,
+    });
+  }, true);
+  window.addEventListener('unhandledrejection', (e) => {
+    send({
+      kind: 'unhandledrejection',
+      reason: e.reason && (e.reason.stack || e.reason.message || String(e.reason)),
+    });
+  });
+
+  // Console
+  for (const level of ['log','info','warn','error','debug']) {
+    const original = console[level];
+    console[level] = function(...args) {
+      try { send({ kind: 'console', level, args: args.map((a) => safe(a)) }); } catch {}
+      return original.apply(this, args);
+    };
+  }
+
+  // fetch
+  const origFetch = window.fetch.bind(window);
+  window.fetch = async function(input, init) {
+    const method = (init && init.method) || (input && input.method) || 'GET';
+    const url = typeof input === 'string' ? input : (input && (input.url || String(input)));
+    const start = Date.now();
+    try {
+      const res = await origFetch(input, init);
+      send({ kind: 'fetch', method, url, status: res.status, ok: res.ok, durationMs: Date.now() - start });
+      return res;
+    } catch (err) {
+      send({ kind: 'fetch', method, url, error: err && (err.message || String(err)), durationMs: Date.now() - start });
+      throw err;
+    }
+  };
+
+  // Route changes (History API + popstate)
+  const origPush = history.pushState;
+  const origReplace = history.replaceState;
+  function notify(from) { send({ kind: 'route', url: location.href, from }); }
+  history.pushState = function(...args) { const from = location.href; const r = origPush.apply(this, args); notify(from); return r; };
+  history.replaceState = function(...args) { const from = location.href; const r = origReplace.apply(this, args); notify(from); return r; };
+  window.addEventListener('popstate', () => notify(undefined));
+
+  function safe(v) {
+    if (v === null) return null;
+    const t = typeof v;
+    if (t === 'string' || t === 'number' || t === 'boolean') return v;
+    try { return JSON.parse(JSON.stringify(v)); } catch { return String(v); }
+  }
+})();
+`;
+}

package/lib/types.d.ts

@@ -0,0 +1,78 @@
+/**
+ * The wire format used between the injected `@lensmcp/client-runtime`
+ * and the Vite plugin's WebSocket. Kept intentionally narrow — the
+ * client runtime *only* emits these envelopes, never anything else.
+ */
+export type ClientEnvelope = ({
+    kind: 'error';
+    at: number;
+    message: string;
+    stack?: string;
+    source?: string;
+    lineno?: number;
+    colno?: number;
+} | {
+    kind: 'unhandledrejection';
+    at: number;
+    reason: string;
+} | {
+    kind: 'console';
+    at: number;
+    level: 'log' | 'info' | 'warn' | 'error' | 'debug';
+    args: unknown[];
+} | {
+    kind: 'fetch';
+    at: number;
+    method: string;
+    url: string;
+    status?: number;
+    durationMs?: number;
+    ok?: boolean;
+    error?: string;
+} | {
+    kind: 'route';
+    at: number;
+    url: string;
+    from?: string;
+} | {
+    kind: 'ready';
+    at: number;
+    userAgent: string;
+    url: string;
+} | {
+    kind: 'publish';
+    at: number;
+    source: string;
+    category: string;
+    severity?: string;
+    title: string;
+    message?: string;
+    fingerprint?: string;
+    context?: Record<string, unknown>;
+    raw?: unknown;
+}) & {
+    /** Per-tab identity stamped by the client runtime (sessionStorage is per-tab) — keys `browser://tabs`. */
+    tabId?: string;
+};
+export interface LensmcpViteOptions {
+    /** Whether the plugin should attach anything. Production: false. */
+    enabled?: boolean;
+    /** Override the WS port. By default an ephemeral port is selected. */
+    wsPort?: number;
+    /** Bind address for the WS. Localhost by default. */
+    wsHost?: string;
+    /** Inject the client runtime via <script>. Default true. */
+    injectClient?: boolean;
+    /** Alias `valtio` → the instrumented drop-in in dev. Default true. */
+    aliasValtio?: boolean;
+    /** Run the LensMCP source transform (root-wrap + hooks + JSX ids). Default true. */
+    transformSource?: boolean;
+}
+export interface LensmcpViteRuntime {
+    /**
+     * The WS port the plugin is listening on. Available after Vite's
+     * `configureServer` hook fires.
+     */
+    wsPort(): number | undefined;
+}
+//# sourceMappingURL=types.d.ts.map

package/lib/types.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"types.d.ts","sourceRoot":"","sources":["../../src/lib/types.ts"],"names":[],"mappings":"AAAA;;;;GAIG;AACH,MAAM,MAAM,cAAc,GAAG,CACzB;IAAE,IAAI,EAAE,OAAO,CAAC;IAAC,EAAE,EAAE,MAAM,CAAC;IAAC,OAAO,EAAE,MAAM,CAAC;IAAC,KAAK,CAAC,EAAE,MAAM,CAAC;IAAC,MAAM,CAAC,EAAE,MAAM,CAAC;IAAC,MAAM,CAAC,EAAE,MAAM,CAAC;IAAC,KAAK,CAAC,EAAE,MAAM,CAAA;CAAE,GAChH;IAAE,IAAI,EAAE,oBAAoB,CAAC;IAAC,EAAE,EAAE,MAAM,CAAC;IAAC,MAAM,EAAE,MAAM,CAAA;CAAE,GAC1D;IAAE,IAAI,EAAE,SAAS,CAAC;IAAC,EAAE,EAAE,MAAM,CAAC;IAAC,KAAK,EAAE,KAAK,GAAG,MAAM,GAAG,MAAM,GAAG,OAAO,GAAG,OAAO,CAAC;IAAC,IAAI,EAAE,OAAO,EAAE,CAAA;CAAE,GACpG;IAAE,IAAI,EAAE,OAAO,CAAC;IAAC,EAAE,EAAE,MAAM,CAAC;IAAC,MAAM,EAAE,MAAM,CAAC;IAAC,GAAG,EAAE,MAAM,CAAC;IAAC,MAAM,CAAC,EAAE,MAAM,CAAC;IAAC,UAAU,CAAC,EAAE,MAAM,CAAC;IAAC,EAAE,CAAC,EAAE,OAAO,CAAC;IAAC,KAAK,CAAC,EAAE,MAAM,CAAA;CAAE,GAC9H;IAAE,IAAI,EAAE,OAAO,CAAC;IAAC,EAAE,EAAE,MAAM,CAAC;IAAC,GAAG,EAAE,MAAM,CAAC;IAAC,IAAI,CAAC,EAAE,MAAM,CAAA;CAAE,GACzD;IAAE,IAAI,EAAE,OAAO,CAAC;IAAC,EAAE,EAAE,MAAM,CAAC;IAAC,SAAS,EAAE,MAAM,CAAC;IAAC,GAAG,EAAE,MAAM,CAAA;CAAE,GAK7D;IACE,IAAI,EAAE,SAAS,CAAC;IAChB,EAAE,EAAE,MAAM,CAAC;IACX,MAAM,EAAE,MAAM,CAAC;IACf,QAAQ,EAAE,MAAM,CAAC;IACjB,QAAQ,CAAC,EAAE,MAAM,CAAC;IAClB,KAAK,EAAE,MAAM,CAAC;IACd,OAAO,CAAC,EAAE,MAAM,CAAC;IACjB,WAAW,CAAC,EAAE,MAAM,CAAC;IACrB,OAAO,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC;IAClC,GAAG,CAAC,EAAE,OAAO,CAAC;CACf,CACJ,GAAG;IACF,0GAA0G;IAC1G,KAAK,CAAC,EAAE,MAAM,CAAC;CAChB,CAAC;AAEF,MAAM,WAAW,kBAAkB;IACjC,oEAAoE;IACpE,OAAO,CAAC,EAAE,OAAO,CAAC;IAClB,sEAAsE;IACtE,MAAM,CAAC,EAAE,MAAM,CAAC;IAChB,qDAAqD;IACrD,MAAM,CAAC,EAAE,MAAM,CAAC;IAChB,4DAA4D;IAC5D,YAAY,CAAC,EAAE,OAAO,CAAC;IACvB,sEAAsE;IACtE,WAAW,CAAC,EAAE,OAAO,CAAC;IACtB,oFAAoF;IACpF,eAAe,CAAC,EAAE,OAAO,CAAC;CAC3B;AAED,MAAM,WAAW,kBAAkB;IACjC;;;OAGG;IACH,MAAM,IAAI,MAAM,GAAG,SAAS,CAAC;CAC9B"}

package/lib/types.js

@@ -0,0 +1 @@
+export {};

package/package.json

@@ -0,0 +1,54 @@
+{
+  "name": "@lensmcp/vite-plugin",
+  "version": "1.0.0",
+  "type": "module",
+  "main": "./index.js",
+  "module": "./index.js",
+  "types": "./index.d.ts",
+  "exports": {
+    "./package.json": "./package.json",
+    ".": {
+      "types": "./index.d.ts",
+      "import": "./index.js",
+      "default": "./index.js"
+    }
+  },
+  "dependencies": {
+    "@babel/core": "^7.0.0",
+    "@lensmcp/core": "1.0.0",
+    "@lensmcp/protocol-types": "1.0.0",
+    "@lensmcp/react-instrumentation": "1.0.0",
+    "@lensmcp/valtio-instrumentation": "1.0.0",
+    "tslib": "^2.3.0",
+    "ws": "^8.21.0"
+  },
+  "peerDependencies": {
+    "vite": "^5.0.0 || ^6.0.0 || ^7.0.0 || ^8.0.0"
+  },
+  "license": "Apache-2.0",
+  "homepage": "https://github.com/kiwiapps-ltd/lensmcp#readme",
+  "bugs": {
+    "url": "https://github.com/kiwiapps-ltd/lensmcp/issues"
+  },
+  "engines": {
+    "node": ">=18"
+  },
+  "publishConfig": {
+    "access": "public"
+  },
+  "description": "LensMCP Vite plugin — valtio alias, source transform, and browser event bridge.",
+  "keywords": [
+    "lensmcp",
+    "mcp",
+    "observability",
+    "ai-agents",
+    "claude",
+    "vite",
+    "vite-plugin"
+  ],
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/kiwiapps-ltd/lensmcp.git",
+    "directory": "libs/vite-plugin"
+  }
+}