@harness-fe/webpack 3.0.0

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2025 MorphixAI
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,51 @@
+# @harness-fe/webpack
+
+> Webpack plugin for [Harness-FE](https://github.com/Morphicai/harness-fe) — the frontend harness for AI agents.
+
+Source-aware transform + runtime injection + MCP bridge for Webpack projects. Tags every JSX element with `data-morphix-loc` / `data-morphix-comp` so AI agents can map any UI element back to a file:line:column.
+
+> **Status:** stable for React + Vue 2/3 on Webpack 5. **thread-loader compatible** as of this release.
+
+> **Note:** This package is now a hand-written webpack plugin, not a wrapper around `unplugin.webpack`. The change is invisible to users — same import, same options — but unblocks projects that put `thread-loader` anywhere in their loader chain (typical Vue 2 + TypeScript SFC builds). See [`.changeset/webpack-native-plugin.md`](../../.changeset/webpack-native-plugin.md) for the why.
+
+## Install
+
+```bash
+pnpm add -D @harness-fe/webpack @harness-fe/runtime
+```
+
+## Usage
+
+```js
+// webpack.config.js
+const { harnessFE } = require('@harness-fe/webpack');
+
+module.exports = {
+    plugins: [harnessFE()],
+};
+```
+
+ESM:
+
+```ts
+import { harnessFE } from '@harness-fe/webpack';
+
+export default {
+    plugins: [harnessFE()],
+};
+```
+
+The plugin auto-disables in production builds — zero overhead in your shipped bundle.
+
+## Options
+
+Same as [`@harness-fe/vite`](https://www.npmjs.com/package/@harness-fe/vite). All bundler-specific plugins share the same option surface via the underlying `unplugin`.
+
+## Docs
+
+- [Root README](https://github.com/Morphicai/harness-fe#readme)
+- [Architecture](https://github.com/Morphicai/harness-fe/blob/main/ARCHITECTURE.md)
+
+## License
+
+MIT

package/dist/index.d.ts

@@ -0,0 +1,19 @@
+/**
+ * @harness-fe/webpack — native webpack plugin for Harness-FE.
+ *
+ * Usage:
+ *   const { harnessFE } = require('@harness-fe/webpack')
+ *   // or
+ *   import { harnessFE } from '@harness-fe/webpack'
+ *
+ *   module.exports = { plugins: [harnessFE()] }
+ *
+ * Unlike previous versions (which were thin re-exports of
+ * @harness-fe/unplugin/webpack), this package implements a native webpack
+ * plugin that is compatible with thread-loader. See plugin.ts for the why.
+ */
+export { harnessFE, HarnessFEWebpackPlugin } from './plugin.js';
+export type { HarnessFEOptions } from '@harness-fe/unplugin';
+export { transformJsx, type ComponentMap, type ComponentLocation, type TransformResult, } from '@harness-fe/unplugin';
+import { harnessFE } from './plugin.js';
+export default harnessFE;

package/dist/index.js

@@ -0,0 +1,20 @@
+/**
+ * @harness-fe/webpack — native webpack plugin for Harness-FE.
+ *
+ * Usage:
+ *   const { harnessFE } = require('@harness-fe/webpack')
+ *   // or
+ *   import { harnessFE } from '@harness-fe/webpack'
+ *
+ *   module.exports = { plugins: [harnessFE()] }
+ *
+ * Unlike previous versions (which were thin re-exports of
+ * @harness-fe/unplugin/webpack), this package implements a native webpack
+ * plugin that is compatible with thread-loader. See plugin.ts for the why.
+ */
+export { harnessFE, HarnessFEWebpackPlugin } from './plugin.js';
+// Re-export transform utilities for direct usage (preserves the previous
+// public surface of @harness-fe/webpack@2.x).
+export { transformJsx, } from '@harness-fe/unplugin';
+import { harnessFE } from './plugin.js';
+export default harnessFE;

package/dist/loader.d.ts

@@ -0,0 +1,36 @@
+/**
+ * Webpack loader entrypoint for @harness-fe/webpack.
+ *
+ * IMPORTANT: This file is loaded by webpack's loader runner (potentially
+ * inside a thread-loader worker process). The options object passed to this
+ * loader MUST be pure JSON-serializable data — no plugin instance, no
+ * compiler reference, no closures. The reason this package exists at all is
+ * that unplugin's webpack adapter passes the plugin instance in options,
+ * which closes over `compiler.root` and breaks thread-loader's JSON.stringify.
+ *
+ * The loader collects component locations into a per-call temporary
+ * componentMap, then writes them to `module.buildMeta.harnessCollected`.
+ * The main-process plugin reads buildMeta via `compilation.succeedModule`
+ * and merges the entries into the real shared componentMap.
+ */
+export interface HarnessLoaderOptions {
+    pluginId: string;
+    projectRoot: string;
+    vueOptions: {
+        safeMode: boolean;
+        dryRun: boolean;
+    };
+    disabled: boolean;
+}
+interface LoaderContext {
+    async: () => (err: Error | null, content?: string, map?: object) => void;
+    getOptions: () => HarnessLoaderOptions;
+    resourcePath: string;
+    resourceQuery: string;
+    _module?: {
+        buildMeta?: Record<string, unknown>;
+    };
+}
+export default function harnessLoader(this: LoaderContext, source: string): void;
+export declare const raw = false;
+export {};

package/dist/loader.js

@@ -0,0 +1,54 @@
+/**
+ * Webpack loader entrypoint for @harness-fe/webpack.
+ *
+ * IMPORTANT: This file is loaded by webpack's loader runner (potentially
+ * inside a thread-loader worker process). The options object passed to this
+ * loader MUST be pure JSON-serializable data — no plugin instance, no
+ * compiler reference, no closures. The reason this package exists at all is
+ * that unplugin's webpack adapter passes the plugin instance in options,
+ * which closes over `compiler.root` and breaks thread-loader's JSON.stringify.
+ *
+ * The loader collects component locations into a per-call temporary
+ * componentMap, then writes them to `module.buildMeta.harnessCollected`.
+ * The main-process plugin reads buildMeta via `compilation.succeedModule`
+ * and merges the entries into the real shared componentMap.
+ */
+import { runTransform } from './transform-runner.js';
+export default function harnessLoader(source) {
+    const callback = this.async();
+    const opts = this.getOptions();
+    if (opts.disabled) {
+        callback(null, source);
+        return;
+    }
+    // Fresh map per call — caller-side accumulation lives in main-process
+    // shared-state, fed via module.buildMeta.
+    const localMap = new Map();
+    let out;
+    try {
+        out = runTransform(source, this.resourcePath, this.resourceQuery, opts.projectRoot, { safeMode: opts.vueOptions.safeMode, dryRun: opts.vueOptions.dryRun }, localMap);
+    }
+    catch (err) {
+        // Never break the host build because of a transform bug.
+        callback(null, source);
+        return;
+    }
+    // Forward collected locations to main process via buildMeta.
+    if (localMap.size > 0 && this._module) {
+        const collected = [];
+        for (const [name, locs] of localMap.entries()) {
+            for (const location of locs) {
+                collected.push({ name, location });
+            }
+        }
+        const buildMeta = (this._module.buildMeta ??= {});
+        const existing = buildMeta.harnessCollected ?? [];
+        buildMeta.harnessCollected = existing.concat(collected);
+    }
+    if (!out) {
+        callback(null, source);
+        return;
+    }
+    callback(null, out.code, out.map);
+}
+export const raw = false;

package/dist/plugin.d.ts

@@ -0,0 +1,44 @@
+/**
+ * @harness-fe/webpack — native webpack plugin.
+ *
+ * Why native (vs the unplugin adapter):
+ *   unplugin's webpack adapter passes the plugin instance through a loader's
+ *   `options` field. The plugin instance closes over `compiler` (via the
+ *   `webpack(compiler)` hook), and `compiler.root` self-references the
+ *   compiler — JSON.stringify chokes on the cycle. thread-loader serializes
+ *   downstream loader options when dispatching to its worker pool, so any
+ *   project that puts thread-loader anywhere ahead of harness in the
+ *   resolved loader chain (e.g. a `.ts` rule that vue-loader inlines for
+ *   `<script lang="ts">` SFC blocks) breaks the entire build.
+ *
+ * This native plugin:
+ *   - Registers a separate `enforce: 'pre'` rule pointing at an independent
+ *     loader file (loader.ts) whose options are pure JSON-serializable data.
+ *   - Keeps all stateful work (WebSocket to MCP, log capture, runtime
+ *     injection, error forwarding, HTML injection) in the main process via
+ *     compiler hooks.
+ *   - Aggregates componentMap entries from worker processes via
+ *     `module.buildMeta.harnessCollected`.
+ */
+import { type HarnessFEOptions } from '@harness-fe/unplugin';
+export declare class HarnessFEWebpackPlugin {
+    private readonly pluginId;
+    private readonly options;
+    private projectRoot;
+    private projectId;
+    private readonly mcpUrl;
+    private readonly token;
+    private mcpClient?;
+    private logCleanup?;
+    private identity;
+    constructor(options?: HarnessFEOptions);
+    apply(compiler: any): void;
+    private installRuntimeEntry;
+    private installMcpHooks;
+    private installComponentMapAggregator;
+    private installHtmlInjection;
+    private installErrorForwarding;
+    private injectConfigScript;
+}
+/** Factory matching the previous unplugin-based call shape. */
+export declare function harnessFE(options?: HarnessFEOptions): HarnessFEWebpackPlugin;

package/dist/plugin.js

@@ -0,0 +1,233 @@
+/**
+ * @harness-fe/webpack — native webpack plugin.
+ *
+ * Why native (vs the unplugin adapter):
+ *   unplugin's webpack adapter passes the plugin instance through a loader's
+ *   `options` field. The plugin instance closes over `compiler` (via the
+ *   `webpack(compiler)` hook), and `compiler.root` self-references the
+ *   compiler — JSON.stringify chokes on the cycle. thread-loader serializes
+ *   downstream loader options when dispatching to its worker pool, so any
+ *   project that puts thread-loader anywhere ahead of harness in the
+ *   resolved loader chain (e.g. a `.ts` rule that vue-loader inlines for
+ *   `<script lang="ts">` SFC blocks) breaks the entire build.
+ *
+ * This native plugin:
+ *   - Registers a separate `enforce: 'pre'` rule pointing at an independent
+ *     loader file (loader.ts) whose options are pure JSON-serializable data.
+ *   - Keeps all stateful work (WebSocket to MCP, log capture, runtime
+ *     injection, error forwarding, HTML injection) in the main process via
+ *     compiler hooks.
+ *   - Aggregates componentMap entries from worker processes via
+ *     `module.buildMeta.harnessCollected`.
+ */
+import { createRequire } from 'node:module';
+import { fileURLToPath } from 'node:url';
+import { dirname, resolve as resolvePath } from 'node:path';
+import { createMcpClient, createBuildIdentity, installNodeLogCapture, appendTokenQuery, } from '@harness-fe/unplugin';
+import { DEFAULT_WS_PORT } from '@harness-fe/protocol';
+import { getOrCreateComponentMap } from './shared-state.js';
+const require = createRequire(import.meta.url);
+const __filename = fileURLToPath(import.meta.url);
+const __dirname = dirname(__filename);
+function newPluginId() {
+    const g = globalThis;
+    if (g.crypto?.randomUUID)
+        return g.crypto.randomUUID();
+    return `harness-${Date.now()}-${Math.random().toString(36).slice(2)}`;
+}
+export class HarnessFEWebpackPlugin {
+    pluginId = newPluginId();
+    options;
+    projectRoot = process.cwd();
+    projectId;
+    mcpUrl;
+    token;
+    mcpClient;
+    logCleanup;
+    identity = createBuildIdentity({
+        userBuildId: undefined,
+        userDisplayName: undefined,
+    });
+    constructor(options = {}) {
+        this.options = options;
+        this.projectId = options.projectId ?? 'unknown-project';
+        const baseUrl = options.mcpUrl ??
+            process.env.HARNESS_FE_URL ??
+            `ws://127.0.0.1:${DEFAULT_WS_PORT}`;
+        this.token = options.token ?? process.env.HARNESS_FE_TOKEN;
+        this.mcpUrl = appendTokenQuery(baseUrl, this.token);
+        this.identity = createBuildIdentity({
+            userBuildId: options.buildId,
+            userDisplayName: options.displayName,
+        });
+    }
+    apply(compiler) {
+        if (this.options.disabled)
+            return;
+        this.projectRoot = compiler.options?.context ?? process.cwd();
+        // Resolve loader path. require.resolve gives an absolute path that
+        // webpack can hand to loader-runner regardless of host project's
+        // module resolution config.
+        const loaderPath = resolvePath(__dirname, 'loader.js');
+        const loaderOptions = {
+            pluginId: this.pluginId,
+            projectRoot: this.projectRoot,
+            vueOptions: {
+                safeMode: this.options.safeMode !== false,
+                dryRun: process.env.HARNESS_FE_DRY_RUN === '1',
+            },
+            disabled: false,
+        };
+        // Register the transform loader as a pre-rule.
+        compiler.options.module ??= { rules: [] };
+        compiler.options.module.rules ??= [];
+        compiler.options.module.rules.unshift({
+            test: /\.([jt]sx|vue)($|\?)/,
+            exclude: /[\\/]node_modules[\\/]/,
+            enforce: 'pre',
+            use: [
+                {
+                    loader: loaderPath,
+                    options: loaderOptions,
+                    ident: `harness-fe-${this.pluginId}`,
+                },
+            ],
+        });
+        // Skip the rest in production builds — runtime injection and MCP
+        // connection are dev-only conveniences.
+        if (compiler.options?.mode === 'production')
+            return;
+        this.installRuntimeEntry(compiler);
+        this.installMcpHooks(compiler);
+        this.installComponentMapAggregator(compiler);
+        this.installHtmlInjection(compiler);
+        this.installErrorForwarding(compiler);
+    }
+    installRuntimeEntry(compiler) {
+        try {
+            const webpackPkg = require('webpack');
+            const { EntryPlugin } = webpackPkg;
+            const runtimeEntry = require.resolve('@harness-fe/runtime');
+            new EntryPlugin(compiler.context ?? this.projectRoot, runtimeEntry, {
+                name: undefined,
+            }).apply(compiler);
+        }
+        catch (err) {
+            console.warn('[harness-fe] failed to register runtime entry via webpack.EntryPlugin:', err);
+        }
+    }
+    installMcpHooks(compiler) {
+        const ctx = {
+            get projectId() {
+                return self.projectId;
+            },
+            get mcpUrl() {
+                return self.mcpUrl;
+            },
+            get token() {
+                return self.token;
+            },
+            peerRole: 'webpack-plugin',
+            get parentProjectId() {
+                return self.options.parentProjectId;
+            },
+            get projectRoot() {
+                return self.projectRoot;
+            },
+            get componentMap() {
+                return getOrCreateComponentMap(self.pluginId);
+            },
+            getBuildId: () => this.identity.getBuildId(this.projectRoot),
+            getDisplayName: () => this.identity.getDisplayName(this.projectRoot),
+        };
+        const self = this;
+        compiler.hooks.afterEnvironment.tap('harness-fe', () => {
+            const client = createMcpClient(ctx);
+            this.mcpClient = client;
+            client.connect();
+            this.logCleanup = installNodeLogCapture((name, payload) => client.emitEvent(name, payload));
+        });
+        compiler.hooks.shutdown?.tap('harness-fe', () => {
+            this.logCleanup?.();
+            this.logCleanup = undefined;
+            this.mcpClient?.disconnect();
+            this.mcpClient = undefined;
+        });
+    }
+    installComponentMapAggregator(compiler) {
+        const pluginId = this.pluginId;
+        compiler.hooks.compilation.tap('harness-fe', (compilation) => {
+            compilation.hooks.succeedModule.tap('harness-fe', (module) => {
+                const collected = module.buildMeta?.harnessCollected;
+                if (!collected?.length)
+                    return;
+                const map = getOrCreateComponentMap(pluginId);
+                for (const { name, location } of collected) {
+                    const existing = map.get(name) ?? [];
+                    existing.push(location);
+                    map.set(name, existing);
+                }
+            });
+        });
+    }
+    installHtmlInjection(compiler) {
+        compiler.hooks.compilation.tap('harness-fe', (compilation) => {
+            // Prefer html-webpack-plugin hooks when available.
+            try {
+                const HtmlPlugin = require('html-webpack-plugin');
+                const hooks = HtmlPlugin.getHooks(compilation);
+                hooks.beforeEmit.tapAsync('harness-fe', (data, cb) => {
+                    data.html = this.injectConfigScript(data.html);
+                    cb(null, data);
+                });
+            }
+            catch {
+                // Fallback: rewrite html assets directly.
+                const { Compilation, sources } = require('webpack');
+                compilation.hooks.processAssets.tap({
+                    name: 'harness-fe',
+                    stage: Compilation.PROCESS_ASSETS_STAGE_OPTIMIZE_INLINE,
+                }, (assets) => {
+                    for (const [name, source] of Object.entries(assets)) {
+                        if (!name.endsWith('.html'))
+                            continue;
+                        const html = source.source();
+                        if (typeof html !== 'string')
+                            continue;
+                        compilation.updateAsset(name, new sources.RawSource(this.injectConfigScript(html)));
+                    }
+                });
+            }
+        });
+    }
+    installErrorForwarding(compiler) {
+        compiler.hooks.done.tap('harness-fe', (stats) => {
+            if (!this.mcpClient || !stats.hasErrors())
+                return;
+            const errors = stats.compilation?.errors ?? [];
+            for (const err of errors) {
+                this.mcpClient.emitEvent('error', {
+                    message: err.message ?? String(err),
+                    file: err.module?.resource ?? undefined,
+                });
+            }
+        });
+    }
+    injectConfigScript(html) {
+        const injection = `<!-- @harness-fe injected (dev only) -->
+<script>
+window.__HARNESS_FE__ = ${JSON.stringify({
+            projectId: this.projectId,
+            mcpUrl: this.mcpUrl,
+            buildId: this.identity.getBuildId(this.projectRoot),
+            parentProjectId: this.options.parentProjectId,
+            displayName: this.identity.getDisplayName(this.projectRoot),
+        })};
+</script>`;
+        return html.replace(/<\/head>/i, `${injection}\n</head>`);
+    }
+}
+/** Factory matching the previous unplugin-based call shape. */
+export function harnessFE(options = {}) {
+    return new HarnessFEWebpackPlugin(options);
+}

package/dist/shared-state.d.ts

@@ -0,0 +1,16 @@
+/**
+ * Module-level componentMap registry keyed by plugin instance id.
+ *
+ * Used by the main webpack process to accumulate component locations forwarded
+ * from worker processes via `module.buildMeta.harnessCollected`. The MCP
+ * client (also main-process only) reads from this map to answer
+ * `project.where_is` / `project.module_graph` queries.
+ *
+ * thread-loader workers fork separate Node processes, so they get their own
+ * empty `maps` instance — but the loader in workers doesn't persist anything
+ * here. It writes collected locations to `module.buildMeta` and the main
+ * process aggregates them via the `succeedModule` hook.
+ */
+import type { ComponentMap } from '@harness-fe/unplugin';
+export declare function getOrCreateComponentMap(pluginId: string): ComponentMap;
+export declare function clearComponentMap(pluginId: string): void;

package/dist/shared-state.js

@@ -0,0 +1,25 @@
+/**
+ * Module-level componentMap registry keyed by plugin instance id.
+ *
+ * Used by the main webpack process to accumulate component locations forwarded
+ * from worker processes via `module.buildMeta.harnessCollected`. The MCP
+ * client (also main-process only) reads from this map to answer
+ * `project.where_is` / `project.module_graph` queries.
+ *
+ * thread-loader workers fork separate Node processes, so they get their own
+ * empty `maps` instance — but the loader in workers doesn't persist anything
+ * here. It writes collected locations to `module.buildMeta` and the main
+ * process aggregates them via the `succeedModule` hook.
+ */
+const maps = new Map();
+export function getOrCreateComponentMap(pluginId) {
+    let m = maps.get(pluginId);
+    if (!m) {
+        m = new Map();
+        maps.set(pluginId, m);
+    }
+    return m;
+}
+export function clearComponentMap(pluginId) {
+    maps.delete(pluginId);
+}

package/dist/transform-runner.d.ts

@@ -0,0 +1,15 @@
+/**
+ * Pure transform dispatcher — picks the right transform function for a
+ * given file id (.vue / .vue?type=template / .vue?other-sub-module / .tsx /
+ * .jsx) and returns the transformed source + map.
+ *
+ * The componentMap is supplied per-call so the loader can collect new
+ * locations in a temporary map and forward them via module.buildMeta to
+ * the main process (where thread-loader is not in the picture).
+ */
+import { type ComponentMap, type VueTransformOptions } from '@harness-fe/unplugin';
+export interface RunTransformResult {
+    code: string;
+    map?: object;
+}
+export declare function runTransform(source: string, resourcePath: string, resourceQuery: string, projectRoot: string, vueOptions: VueTransformOptions, componentMap: ComponentMap): RunTransformResult | null;

package/dist/transform-runner.js

@@ -0,0 +1,50 @@
+/**
+ * Pure transform dispatcher — picks the right transform function for a
+ * given file id (.vue / .vue?type=template / .vue?other-sub-module / .tsx /
+ * .jsx) and returns the transformed source + map.
+ *
+ * The componentMap is supplied per-call so the loader can collect new
+ * locations in a temporary map and forward them via module.buildMeta to
+ * the main process (where thread-loader is not in the picture).
+ */
+import { readFileSync } from 'node:fs';
+import { relative } from 'node:path';
+import { transformJsx, transformVueSFC, transformVueTemplate, resolveVueComponentName, getTemplateLineOffset, } from '@harness-fe/unplugin';
+export function runTransform(source, resourcePath, resourceQuery, projectRoot, vueOptions, componentMap) {
+    const rel = relative(projectRoot, resourcePath);
+    // Vue template virtual sub-module.
+    if (resourcePath.endsWith('.vue') &&
+        /[?&]vue\b/.test(resourceQuery) &&
+        /[?&]type=template\b/.test(resourceQuery)) {
+        let componentName;
+        let lineOffset = 0;
+        try {
+            const sfcSource = readFileSync(resourcePath, 'utf-8');
+            componentName = resolveVueComponentName(sfcSource, rel);
+            lineOffset = getTemplateLineOffset(sfcSource, rel);
+        }
+        catch {
+            /* fall through with no offset / no name */
+        }
+        const out = transformVueTemplate(source, rel, componentName, componentMap, lineOffset, vueOptions);
+        if (!out)
+            return null;
+        return { code: out.code, map: out.map };
+    }
+    // Plain .vue request: full SFC transform.
+    if (resourcePath.endsWith('.vue') && !resourceQuery) {
+        const out = transformVueSFC(source, rel, componentMap, vueOptions);
+        if (!out)
+            return null;
+        return { code: out.code, map: out.map };
+    }
+    // Every other .vue sub-module (script / style) is a no-op — the
+    // information was already collected from the SFC and template variants.
+    if (resourcePath.endsWith('.vue'))
+        return null;
+    // .jsx / .tsx
+    const out = transformJsx(source, rel, componentMap);
+    if (!out)
+        return null;
+    return { code: out.code, map: out.map };
+}

package/package.json

@@ -0,0 +1,54 @@
+{
+  "name": "@harness-fe/webpack",
+  "version": "3.0.0",
+  "description": "Native webpack plugin for Harness-FE: source-aware transforms, runtime injection, and MCP bridge. thread-loader compatible.",
+  "type": "module",
+  "license": "MIT",
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/Morphicai/harness-fe.git",
+    "directory": "packages/webpack-plugin"
+  },
+  "homepage": "https://github.com/Morphicai/harness-fe#readme",
+  "bugs": {
+    "url": "https://github.com/Morphicai/harness-fe/issues"
+  },
+  "main": "dist/index.js",
+  "types": "dist/index.d.ts",
+  "exports": {
+    ".": {
+      "types": "./dist/index.d.ts",
+      "default": "./dist/index.js"
+    },
+    "./loader": {
+      "types": "./dist/loader.d.ts",
+      "default": "./dist/loader.js"
+    }
+  },
+  "files": [
+    "dist",
+    "src",
+    "README.md",
+    "LICENSE"
+  ],
+  "dependencies": {
+    "@harness-fe/unplugin": "3.0.0",
+    "@harness-fe/protocol": "3.0.0"
+  },
+  "peerDependencies": {
+    "webpack": "^5.0.0"
+  },
+  "devDependencies": {
+    "typescript": "^5.6.0",
+    "vitest": "^2.1.9",
+    "webpack": "^5.107.0"
+  },
+  "publishConfig": {
+    "access": "public"
+  },
+  "scripts": {
+    "build": "tsc",
+    "typecheck": "tsc --noEmit",
+    "test": "vitest run --passWithNoTests"
+  }
+}