every-plugin 0.4.4 → 0.4.6

package/dist/build/rspack/index.mjs

@@ -0,0 +1,298 @@
+import { r as __require } from "../../chunk-QQAxy9l9.mjs";
+import { t as getNormalizedRemoteName } from "../../normalize-D7nae0Hn.mjs";
+import { t as require_package } from "../../package-Dn-xZ55N.mjs";
+import { rspack } from "@rspack/core";
+import path from "node:path";
+import fs from "node:fs";
+
+//#region src/build/rspack/utils.ts
+function getPluginInfo(context) {
+	const pkgPath = path.join(context, "package.json");
+	const pkg = JSON.parse(fs.readFileSync(pkgPath, "utf-8"));
+	return {
+		name: pkg.name,
+		version: pkg.version,
+		normalizedName: getNormalizedRemoteName(pkg.name),
+		dependencies: pkg.dependencies || {},
+		peerDependencies: pkg.peerDependencies || {}
+	};
+}
+const loadedModules = /* @__PURE__ */ new Set();
+function loadDevConfig(devConfigPath) {
+	try {
+		const fullPath = path.resolve(devConfigPath);
+		if (loadedModules.has(fullPath)) {
+			delete __require.cache[fullPath];
+			const dirPath = path.dirname(fullPath);
+			for (const key of Object.keys(__require.cache)) if (key.startsWith(dirPath) && key !== fullPath) delete __require.cache[key];
+		}
+		const module = __require(fullPath).default;
+		loadedModules.add(fullPath);
+		return module;
+	} catch (error) {
+		console.warn(`Could not load dev config from ${devConfigPath}:`, error.message);
+		return null;
+	}
+}
+
+//#endregion
+//#region src/build/rspack/module-federation.ts
+function buildSharedDependencies(pluginInfo) {
+	const everyPluginPkg = require_package();
+	return {
+		"every-plugin": {
+			version: everyPluginPkg.version,
+			singleton: true,
+			requiredVersion: `${everyPluginPkg.version}`,
+			strictVersion: false,
+			eager: false
+		},
+		effect: {
+			version: everyPluginPkg.dependencies.effect,
+			singleton: true,
+			requiredVersion: `${everyPluginPkg.dependencies.effect}`,
+			strictVersion: false,
+			eager: false
+		},
+		zod: {
+			version: everyPluginPkg.dependencies.zod,
+			singleton: true,
+			requiredVersion: `${everyPluginPkg.dependencies.zod}`,
+			strictVersion: false,
+			eager: false
+		},
+		"@orpc/contract": {
+			version: everyPluginPkg.dependencies["@orpc/contract"],
+			singleton: true,
+			requiredVersion: `${everyPluginPkg.dependencies["@orpc/contract"]}`,
+			strictVersion: false,
+			eager: false
+		},
+		"@orpc/server": {
+			version: everyPluginPkg.dependencies["@orpc/server"],
+			singleton: true,
+			requiredVersion: `${everyPluginPkg.dependencies["@orpc/server"]}`,
+			strictVersion: false,
+			eager: false
+		}
+	};
+}
+
+//#endregion
+//#region src/build/rspack/dev-server-middleware.ts
+function setupPluginMiddleware(devServer, pluginInfo, devConfig, port) {
+	let handlers = {
+		rpc: null,
+		api: null
+	};
+	let cleanup = null;
+	const performCleanup = async () => {
+		if (cleanup) {
+			await cleanup();
+			cleanup = null;
+		}
+	};
+	(async () => {
+		await performCleanup();
+		try {
+			const { createPluginRuntime } = await import("../../index.mjs");
+			const { RPCHandler } = await import("@orpc/server/fetch");
+			const { onError } = await import("@orpc/server");
+			const { OpenAPIHandler } = await import("../../fetch-KLktuWuM.mjs");
+			const { OpenAPIReferencePlugin } = await import("../../plugins-Ps5Xxpk2.mjs");
+			const { ZodToJsonSchemaConverter } = await import("../../zod4-VpXuwRO7.mjs");
+			const pluginId = devConfig?.pluginId || pluginInfo.normalizedName;
+			const runtime = createPluginRuntime({ registry: { [pluginId]: { remoteUrl: `http://localhost:${port}/remoteEntry.js` } } });
+			const loaded = await runtime.usePlugin(pluginId, devConfig?.config);
+			cleanup = async () => {
+				if (loaded && typeof loaded.dispose === "function") await loaded.dispose();
+				if (runtime && typeof runtime.cleanup === "function") await runtime.cleanup();
+				handlers.rpc = null;
+				handlers.api = null;
+				if (devServer.app.locals.handlers) devServer.app.locals.handlers = null;
+			};
+			handlers.rpc = new RPCHandler(loaded.router, { interceptors: [onError((error) => {
+				console.error("🔴 RPC Error:", error);
+			})] });
+			handlers.api = new OpenAPIHandler(loaded.router, {
+				plugins: [new OpenAPIReferencePlugin({ schemaConverters: [new ZodToJsonSchemaConverter()] })],
+				interceptors: [onError((error) => {
+					console.error("🔴 OpenAPI Error:", error);
+				})]
+			});
+			console.log(`╭─────────────────────────────────────────────`);
+			console.log(`│  ✅ Plugin dev server ready: `);
+			console.log(`├─────────────────────────────────────────────`);
+			console.log(`│  📡 RPC:    http://localhost:${port}/api/rpc`);
+			console.log(`│  📖 Docs:   http://localhost:${port}/api`);
+			console.log(`│  💚 Health: http://localhost:${port}/`);
+			console.log(`╰─────────────────────────────────────────────`);
+			devServer.app.locals.handlers = handlers;
+			if (devServer.server) devServer.server.once("close", async () => {
+				await performCleanup();
+			});
+		} catch (error) {
+			console.error("❌ Failed to load plugin:", error);
+			await performCleanup();
+		}
+	})();
+	process.once("SIGINT", async () => {
+		await performCleanup();
+	});
+	process.once("SIGTERM", async () => {
+		await performCleanup();
+	});
+	devServer.app.get("/", (req, res) => {
+		res.json({
+			ok: true,
+			plugin: pluginInfo.normalizedName,
+			version: pluginInfo.version,
+			status: devServer.app.locals.handlers?.rpc ? "ready" : "loading",
+			endpoints: {
+				health: "/",
+				docs: "/api",
+				rpc: "/api/rpc"
+			}
+		});
+	});
+	const handleApiRequest = async (req, res) => {
+		const apiHandler = devServer.app.locals.handlers?.api;
+		if (!apiHandler) return res.status(503).json({ error: "Plugin still loading..." });
+		try {
+			const url = `http://${req.headers.host}${req.url}`;
+			const webRequest = new Request(url, {
+				method: req.method,
+				headers: req.headers,
+				body: req.method !== "GET" && req.method !== "HEAD" ? req : void 0
+			});
+			const result = await apiHandler.handle(webRequest, {
+				prefix: "/api",
+				context: {}
+			});
+			if (result.response) {
+				res.status(result.response.status);
+				result.response.headers.forEach((value, key) => {
+					res.setHeader(key, value);
+				});
+				const text = await result.response.text();
+				res.send(text);
+			} else res.status(404).send("Not Found");
+		} catch (error) {
+			console.error("OpenAPI error:", error);
+			res.status(500).json({ error: error.message });
+		}
+	};
+	devServer.app.all("/api", handleApiRequest);
+	devServer.app.all("/api/*", handleApiRequest);
+	devServer.app.all("/api/rpc/*", async (req, res) => {
+		const rpcHandler = devServer.app.locals.handlers?.rpc;
+		if (!rpcHandler) return res.status(503).json({ error: "Plugin still loading..." });
+		try {
+			const url = `http://${req.headers.host}${req.url}`;
+			const webRequest = new Request(url, {
+				method: req.method,
+				headers: req.headers,
+				body: req.method !== "GET" && req.method !== "HEAD" ? req : void 0
+			});
+			const result = await rpcHandler.handle(webRequest, {
+				prefix: "/api/rpc",
+				context: {}
+			});
+			if (result.response) {
+				res.status(result.response.status);
+				result.response.headers.forEach((value, key) => {
+					res.setHeader(key, value);
+				});
+				const text = await result.response.text();
+				res.send(text);
+			} else res.status(404).send("Not Found");
+		} catch (error) {
+			console.error("RPC error:", error);
+			res.status(500).json({ error: error.message });
+		}
+	});
+}
+
+//#endregion
+//#region src/build/rspack/plugin.ts
+var EveryPluginDevServer = class {
+	name = "EveryPluginDevServer";
+	constructor(options = {}) {
+		this.options = options;
+	}
+	apply(compiler) {
+		const pluginInfo = getPluginInfo(compiler.options.context || process.cwd());
+		const devConfig = loadDevConfig(this.options.devConfigPath || "./plugin.dev.ts");
+		const port = this.options.port || devConfig?.port || 3999;
+		this.configureDefaults(compiler, pluginInfo);
+		if (!compiler.options.devServer) compiler.options.devServer = {};
+		this.configureDevServer(compiler, pluginInfo, devConfig, port);
+		new rspack.container.ModuleFederationPlugin({
+			name: pluginInfo.normalizedName,
+			filename: "remoteEntry.js",
+			runtimePlugins: [__require.resolve("@module-federation/node/runtimePlugin")],
+			library: { type: "commonjs-module" },
+			exposes: { "./plugin": "./src/index.ts" },
+			shared: buildSharedDependencies(pluginInfo)
+		}).apply(compiler);
+	}
+	configureDefaults(compiler, pluginInfo) {
+		const context = compiler.options.context || process.cwd();
+		if (!compiler.options.output) compiler.options.output = {};
+		compiler.options.output.uniqueName = pluginInfo.normalizedName;
+		compiler.options.output.publicPath = "auto";
+		compiler.options.output.path = path.resolve(context, "dist");
+		compiler.options.output.clean = true;
+		compiler.options.output.library = { type: "commonjs-module" };
+		if (!compiler.options.entry) compiler.options.entry = { main: { import: ["./src/index"] } };
+		if (!compiler.options.target) compiler.options.target = "async-node";
+		if (!compiler.options.mode) compiler.options.mode = process.env.NODE_ENV === "development" ? "development" : "production";
+		if (!compiler.options.devtool) compiler.options.devtool = "source-map";
+		if (!compiler.options.infrastructureLogging) compiler.options.infrastructureLogging = { level: "warn" };
+		this.ensureTypeScriptLoader(compiler);
+		if (!compiler.options.resolve) compiler.options.resolve = {};
+		compiler.options.resolve.extensions = [
+			"...",
+			".tsx",
+			".ts"
+		];
+	}
+	ensureTypeScriptLoader(compiler) {
+		if (!compiler.options.module) compiler.options.module = { rules: [] };
+		if (!compiler.options.module.rules) compiler.options.module.rules = [];
+		if (!compiler.options.module.rules.some((rule) => typeof rule === "object" && rule !== null && "test" in rule && rule.test instanceof RegExp && rule.test.test(".ts"))) compiler.options.module.rules.push({
+			test: /\.tsx?$/,
+			use: "builtin:swc-loader",
+			exclude: /node_modules/
+		});
+	}
+	configureDevServer(compiler, pluginInfo, devConfig, port) {
+		if (!compiler.options.devServer) return;
+		const context = compiler.options.context || process.cwd();
+		const originalSetup = compiler.options.devServer.setupMiddlewares;
+		compiler.options.devServer.port = port;
+		compiler.options.devServer.static = path.join(context, "dist");
+		compiler.options.devServer.hot = true;
+		compiler.options.devServer.devMiddleware = { writeToDisk: true };
+		compiler.options.devServer.headers = {
+			"Access-Control-Allow-Origin": "*",
+			"Access-Control-Allow-Methods": "GET, POST, PUT, DELETE, PATCH, OPTIONS",
+			"Access-Control-Allow-Headers": "X-Requested-With, content-type, Authorization"
+		};
+		compiler.options.devServer.client = {
+			logging: "warn",
+			overlay: {
+				warnings: false,
+				errors: true
+			}
+		};
+		compiler.options.devServer.setupMiddlewares = (middlewares, devServer) => {
+			setupPluginMiddleware(devServer, pluginInfo, devConfig, port);
+			return originalSetup ? originalSetup(middlewares, devServer) : middlewares;
+		};
+	}
+};
+
+//#endregion
+export { EveryPluginDevServer };
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"file":"index.mjs","names":["handlers: { rpc: any, api: any }","cleanup: (() => Promise<void>) | null","options: EveryPluginOptions"],"sources":["../../../src/build/rspack/utils.ts","../../../src/build/rspack/module-federation.ts","../../../src/build/rspack/dev-server-middleware.ts","../../../src/build/rspack/plugin.ts"],"sourcesContent":["import path from 'node:path';\nimport fs from 'node:fs';\nimport { getNormalizedRemoteName } from 'every-plugin/normalize';\n\nexport interface PluginInfo {\n  name: string;\n  version: string;\n  normalizedName: string;\n  dependencies: Record<string, string>;\n  peerDependencies: Record<string, string>;\n}\n\nexport function getPluginInfo(context: string): PluginInfo {\n  const pkgPath = path.join(context, 'package.json');\n  const pkg = JSON.parse(fs.readFileSync(pkgPath, 'utf-8'));\n\n  return {\n    name: pkg.name,\n    version: pkg.version,\n    normalizedName: getNormalizedRemoteName(pkg.name),\n    dependencies: pkg.dependencies || {},\n    peerDependencies: pkg.peerDependencies || {},\n  };\n}\n\nconst loadedModules = new Set<string>();\n\nexport function loadDevConfig(devConfigPath: string) {\n  try {\n    const fullPath = path.resolve(devConfigPath);\n    \n    if (loadedModules.has(fullPath)) {\n      delete require.cache[fullPath];\n      const dirPath = path.dirname(fullPath);\n      for (const key of Object.keys(require.cache)) {\n        if (key.startsWith(dirPath) && key !== fullPath) {\n          delete require.cache[key];\n        }\n      }\n    }\n    \n    const module = require(fullPath).default;\n    loadedModules.add(fullPath);\n    return module;\n  } catch (error) {\n    console.warn(`Could not load dev config from ${devConfigPath}:`, (error as Error).message);\n    return null;\n  }\n}\n\nexport function cleanupDevConfig() {\n  for (const modulePath of loadedModules) {\n    delete require.cache[modulePath];\n  }\n  loadedModules.clear();\n}\n","import type { PluginInfo } from './utils';\n\nexport function buildSharedDependencies(pluginInfo: PluginInfo) {\n  // Get every-plugin package info for version constraints\n  const everyPluginPkg = require('every-plugin/package.json');\n\n  return {\n    'every-plugin': {\n      version: everyPluginPkg.version,\n      singleton: true,\n      requiredVersion: `${everyPluginPkg.version}`,\n      strictVersion: false,\n      eager: false,\n    },\n    effect: {\n      version: everyPluginPkg.dependencies.effect,\n      singleton: true,\n      requiredVersion: `${everyPluginPkg.dependencies.effect}`,\n      strictVersion: false,\n      eager: false,\n    },\n    zod: {\n      version: everyPluginPkg.dependencies.zod,\n      singleton: true,\n      requiredVersion: `${everyPluginPkg.dependencies.zod}`,\n      strictVersion: false,\n      eager: false,\n    },\n    '@orpc/contract': {\n      version: everyPluginPkg.dependencies['@orpc/contract'],\n      singleton: true,\n      requiredVersion: `${everyPluginPkg.dependencies['@orpc/contract']}`,\n      strictVersion: false,\n      eager: false,\n    },\n    '@orpc/server': {\n      version: everyPluginPkg.dependencies['@orpc/server'],\n      singleton: true,\n      requiredVersion: `${everyPluginPkg.dependencies['@orpc/server']}`,\n      strictVersion: false,\n      eager: false,\n    },\n  };\n}\n","import type { PluginInfo } from './utils';\n\nexport function setupPluginMiddleware(devServer: any, pluginInfo: PluginInfo, devConfig: any, port: number) {\n  let handlers: { rpc: any, api: any } = { rpc: null, api: null };\n  let cleanup: (() => Promise<void>) | null = null;\n\n  const performCleanup = async () => {\n    if (cleanup) {\n      await cleanup();\n      cleanup = null;\n    }\n  };\n\n  (async () => {\n    await performCleanup();\n\n    try {\n      const { createPluginRuntime } = await import('every-plugin');\n      const { RPCHandler } = await import('@orpc/server/fetch');\n      const { onError } = await import('@orpc/server');\n      const { OpenAPIHandler } = await import('@orpc/openapi/fetch');\n      const { OpenAPIReferencePlugin } = await import('@orpc/openapi/plugins');\n      const { ZodToJsonSchemaConverter } = await import('@orpc/zod/zod4');\n\n      const pluginId = devConfig?.pluginId || pluginInfo.normalizedName;\n\n      const runtime = createPluginRuntime({\n        registry: {\n          [pluginId]: {\n            remoteUrl: `http://localhost:${port}/remoteEntry.js`\n          }\n        }\n      });\n\n      const loaded = await runtime.usePlugin(pluginId, devConfig?.config);\n\n      cleanup = async () => {\n        if (loaded && typeof (loaded as any).dispose === 'function') {\n          await (loaded as any).dispose();\n        }\n        if (runtime && typeof (runtime as any).cleanup === 'function') {\n          await (runtime as any).cleanup();\n        }\n        handlers.rpc = null;\n        handlers.api = null;\n        if (devServer.app.locals.handlers) {\n          devServer.app.locals.handlers = null;\n        }\n      };\n\n      // @ts-expect-error no type\n      handlers.rpc = new RPCHandler(loaded.router, {\n        interceptors: [\n          onError((error: any) => {\n            console.error('🔴 RPC Error:', error);\n          }),\n        ]\n      });\n\n      // Create OpenAPI handler for documentation\n      // @ts-expect-error no type\n      handlers.api = new OpenAPIHandler(loaded.router, {\n        plugins: [\n          new OpenAPIReferencePlugin({\n            schemaConverters: [new ZodToJsonSchemaConverter()],\n          }),\n        ],\n        interceptors: [\n          onError((error: any) => {\n            console.error('🔴 OpenAPI Error:', error);\n          }),\n        ]\n      });\n\n      console.log(`╭─────────────────────────────────────────────`);\n      console.log(`│  ✅ Plugin dev server ready: `);\n      console.log(`├─────────────────────────────────────────────`);\n      console.log(`│  📡 RPC:    http://localhost:${port}/api/rpc`);\n      console.log(`│  📖 Docs:   http://localhost:${port}/api`);\n      console.log(`│  💚 Health: http://localhost:${port}/`);\n      console.log(`╰─────────────────────────────────────────────`);\n\n      devServer.app.locals.handlers = handlers;\n\n      if (devServer.server) {\n        devServer.server.once('close', async () => {\n          await performCleanup();\n        });\n      }\n    } catch (error) {\n      console.error('❌ Failed to load plugin:', error);\n      await performCleanup();\n    }\n  })();\n\n  process.once('SIGINT', async () => {\n    await performCleanup();\n  });\n  process.once('SIGTERM', async () => {\n    await performCleanup();\n  });\n\n  // Root health check\n  devServer.app.get('/', (req: any, res: any) => {\n    res.json({\n      ok: true,\n      plugin: pluginInfo.normalizedName,\n      version: pluginInfo.version,\n      status: devServer.app.locals.handlers?.rpc ? 'ready' : 'loading',\n      endpoints: {\n        health: '/',\n        docs: '/api',\n        rpc: '/api/rpc'\n      }\n    });\n  });\n\n  // OpenAPI documentation and REST endpoints at /api and /api/*\n  const handleApiRequest = async (req: any, res: any) => {\n    const apiHandler = devServer.app.locals.handlers?.api;\n    if (!apiHandler) {\n      return res.status(503).json({ error: 'Plugin still loading...' });\n    }\n\n    try {\n      const url = `http://${req.headers.host}${req.url}`;\n      const webRequest = new Request(url, {\n        method: req.method,\n        headers: req.headers,\n        body: req.method !== 'GET' && req.method !== 'HEAD' ? req : undefined\n      });\n\n      const result = await apiHandler.handle(webRequest, {\n        prefix: '/api',\n        context: {}\n      });\n\n      if (result.response) {\n        res.status(result.response.status);\n        result.response.headers.forEach((value: string, key: string) => {\n          res.setHeader(key, value);\n        });\n        const text = await result.response.text();\n        res.send(text);\n      } else {\n        res.status(404).send('Not Found');\n      }\n    } catch (error) {\n      console.error('OpenAPI error:', error);\n      res.status(500).json({ error: (error as Error).message });\n    }\n  };\n\n  devServer.app.all('/api', handleApiRequest);\n  devServer.app.all('/api/*', handleApiRequest);\n\n  // RPC calls at /api/rpc/*\n  devServer.app.all('/api/rpc/*', async (req: any, res: any) => {\n    const rpcHandler = devServer.app.locals.handlers?.rpc;\n    if (!rpcHandler) {\n      return res.status(503).json({ error: 'Plugin still loading...' });\n    }\n\n    try {\n      const url = `http://${req.headers.host}${req.url}`;\n      const webRequest = new Request(url, {\n        method: req.method,\n        headers: req.headers,\n        body: req.method !== 'GET' && req.method !== 'HEAD' ? req : undefined\n      });\n\n      const result = await rpcHandler.handle(webRequest, {\n        prefix: '/api/rpc',\n        context: {}\n      });\n\n      if (result.response) {\n        res.status(result.response.status);\n        result.response.headers.forEach((value: string, key: string) => {\n          res.setHeader(key, value);\n        });\n        const text = await result.response.text();\n        res.send(text);\n      } else {\n        res.status(404).send('Not Found');\n      }\n    } catch (error) {\n      console.error('RPC error:', error);\n      res.status(500).json({ error: (error as Error).message });\n    }\n  });\n}\n","import type { Compiler, RspackPluginInstance } from '@rspack/core';\nimport { rspack } from '@rspack/core';\nimport path from 'node:path';\nimport { getPluginInfo } from './utils';\nimport { loadDevConfig } from './utils';\nimport { buildSharedDependencies } from './module-federation';\nimport { setupPluginMiddleware } from './dev-server-middleware';\n\n\nexport interface EveryPluginOptions {\n  devConfigPath?: string;  // defaults to './plugin.dev.ts'\n  port?: number;           // override plugin.dev.ts port\n  pluginId?: string;       // override auto-detected\n}\n\nexport class EveryPluginDevServer implements RspackPluginInstance {\n  name = 'EveryPluginDevServer';\n\n  constructor(private options: EveryPluginOptions = {}) {}\n\n  apply(compiler: Compiler) {\n    // Load configuration\n    const pluginInfo = getPluginInfo(compiler.options.context || process.cwd());\n    const devConfig = loadDevConfig(this.options.devConfigPath || './plugin.dev.ts');\n    const port = this.options.port || devConfig?.port || 3999;\n\n    // Configure defaults immediately (no hooks needed)\n    this.configureDefaults(compiler, pluginInfo);\n\n    // Initialize devServer if it doesn't exist\n    if (!compiler.options.devServer) {\n      compiler.options.devServer = {};\n    }\n\n    // Configure dev server\n    this.configureDevServer(compiler, pluginInfo, devConfig, port);\n\n    // Apply Module Federation plugin\n    new rspack.container.ModuleFederationPlugin({\n      name: pluginInfo.normalizedName,\n      filename: 'remoteEntry.js',\n      runtimePlugins: [\n        require.resolve('@module-federation/node/runtimePlugin'),\n      ],\n      library: { type: 'commonjs-module' },\n      exposes: {\n        './plugin': './src/index.ts',\n      },\n      shared: buildSharedDependencies(pluginInfo),\n    }).apply(compiler);\n  }\n\n  private configureDefaults(compiler: Compiler, pluginInfo: any) {\n    const context = compiler.options.context || process.cwd();\n\n    // Configure output defaults\n    if (!compiler.options.output) {\n      compiler.options.output = {};\n    }\n    compiler.options.output.uniqueName = pluginInfo.normalizedName;\n    compiler.options.output.publicPath = 'auto';\n    compiler.options.output.path = path.resolve(context, 'dist');\n    compiler.options.output.clean = true;\n    compiler.options.output.library = { type: 'commonjs-module' };\n\n    // Configure entry if not set\n    if (!compiler.options.entry) {\n      compiler.options.entry = {\n        main: {\n          import: ['./src/index']\n        }\n      };\n    }\n\n    // Configure target and mode defaults\n    if (!compiler.options.target) {\n      compiler.options.target = 'async-node';\n    }\n\n    if (!compiler.options.mode) {\n      compiler.options.mode = process.env.NODE_ENV === 'development' ? 'development' : 'production';\n    }\n\n    // Configure devtool\n    if (!compiler.options.devtool) {\n      compiler.options.devtool = 'source-map';\n    }\n\n    // Suppress verbose infrastructure logging\n    if (!compiler.options.infrastructureLogging) {\n      compiler.options.infrastructureLogging = {\n        level: 'warn',  // Only show warnings and errors\n      };\n    }\n\n    // Configure module rules - ensure TypeScript loader is present\n    this.ensureTypeScriptLoader(compiler);\n\n    // Configure resolve extensions\n    if (!compiler.options.resolve) {\n      compiler.options.resolve = {};\n    }\n    compiler.options.resolve.extensions = ['...', '.tsx', '.ts'];\n  }\n\n  private ensureTypeScriptLoader(compiler: Compiler) {\n    if (!compiler.options.module) {\n      compiler.options.module = { rules: [] } as any;\n    }\n\n    if (!compiler.options.module.rules) {\n      compiler.options.module.rules = [];\n    }\n\n    // Check if TypeScript loader is already configured\n    const hasTsLoader = compiler.options.module.rules.some((rule: any) =>\n      typeof rule === 'object' &&\n      rule !== null &&\n      'test' in rule &&\n      rule.test instanceof RegExp &&\n      rule.test.test('.ts')\n    );\n\n    // Add TypeScript loader if not present\n    if (!hasTsLoader) {\n      compiler.options.module.rules.push({\n        test: /\\.tsx?$/,\n        use: 'builtin:swc-loader',\n        exclude: /node_modules/,\n      });\n    }\n  }\n\n  private configureDevServer(compiler: Compiler, pluginInfo: any, devConfig: any, port: number) {\n    if (!compiler.options.devServer) {\n      return; // Should never happen due to check in apply()\n    }\n\n    const context = compiler.options.context || process.cwd();\n    const originalSetup = compiler.options.devServer.setupMiddlewares;\n\n    compiler.options.devServer.port = port;\n    compiler.options.devServer.static = path.join(context, 'dist');\n    compiler.options.devServer.hot = true;\n    compiler.options.devServer.devMiddleware = { writeToDisk: true };\n    compiler.options.devServer.headers = {\n      'Access-Control-Allow-Origin': '*',\n      'Access-Control-Allow-Methods': 'GET, POST, PUT, DELETE, PATCH, OPTIONS',\n      'Access-Control-Allow-Headers': 'X-Requested-With, content-type, Authorization',\n    };\n\n    // Suppress verbose logging\n    compiler.options.devServer.client = {\n      logging: 'warn',  // Only show warnings and errors\n      overlay: {\n        warnings: false,  // Don't show warning overlay\n        errors: true,     // Still show errors\n      },\n    };\n\n    compiler.options.devServer.setupMiddlewares = (middlewares, devServer) => {\n      setupPluginMiddleware(devServer, pluginInfo, devConfig, port);\n      return originalSetup ? originalSetup(middlewares, devServer) : middlewares;\n    };\n  }\n}\n"],"mappings":";;;;;;;;AAYA,SAAgB,cAAc,SAA6B;CACzD,MAAM,UAAU,KAAK,KAAK,SAAS,eAAe;CAClD,MAAM,MAAM,KAAK,MAAM,GAAG,aAAa,SAAS,QAAQ,CAAC;AAEzD,QAAO;EACL,MAAM,IAAI;EACV,SAAS,IAAI;EACb,gBAAgB,wBAAwB,IAAI,KAAK;EACjD,cAAc,IAAI,gBAAgB,EAAE;EACpC,kBAAkB,IAAI,oBAAoB,EAAE;EAC7C;;AAGH,MAAM,gCAAgB,IAAI,KAAa;AAEvC,SAAgB,cAAc,eAAuB;AACnD,KAAI;EACF,MAAM,WAAW,KAAK,QAAQ,cAAc;AAE5C,MAAI,cAAc,IAAI,SAAS,EAAE;AAC/B,oBAAe,MAAM;GACrB,MAAM,UAAU,KAAK,QAAQ,SAAS;AACtC,QAAK,MAAM,OAAO,OAAO,eAAa,MAAM,CAC1C,KAAI,IAAI,WAAW,QAAQ,IAAI,QAAQ,SACrC,kBAAe,MAAM;;EAK3B,MAAM,mBAAiB,SAAS,CAAC;AACjC,gBAAc,IAAI,SAAS;AAC3B,SAAO;UACA,OAAO;AACd,UAAQ,KAAK,kCAAkC,cAAc,IAAK,MAAgB,QAAQ;AAC1F,SAAO;;;;;;AC5CX,SAAgB,wBAAwB,YAAwB;CAE9D,MAAM;AAEN,QAAO;EACL,gBAAgB;GACd,SAAS,eAAe;GACxB,WAAW;GACX,iBAAiB,GAAG,eAAe;GACnC,eAAe;GACf,OAAO;GACR;EACD,QAAQ;GACN,SAAS,eAAe,aAAa;GACrC,WAAW;GACX,iBAAiB,GAAG,eAAe,aAAa;GAChD,eAAe;GACf,OAAO;GACR;EACD,KAAK;GACH,SAAS,eAAe,aAAa;GACrC,WAAW;GACX,iBAAiB,GAAG,eAAe,aAAa;GAChD,eAAe;GACf,OAAO;GACR;EACD,kBAAkB;GAChB,SAAS,eAAe,aAAa;GACrC,WAAW;GACX,iBAAiB,GAAG,eAAe,aAAa;GAChD,eAAe;GACf,OAAO;GACR;EACD,gBAAgB;GACd,SAAS,eAAe,aAAa;GACrC,WAAW;GACX,iBAAiB,GAAG,eAAe,aAAa;GAChD,eAAe;GACf,OAAO;GACR;EACF;;;;;ACxCH,SAAgB,sBAAsB,WAAgB,YAAwB,WAAgB,MAAc;CAC1G,IAAIA,WAAmC;EAAE,KAAK;EAAM,KAAK;EAAM;CAC/D,IAAIC,UAAwC;CAE5C,MAAM,iBAAiB,YAAY;AACjC,MAAI,SAAS;AACX,SAAM,SAAS;AACf,aAAU;;;AAId,EAAC,YAAY;AACX,QAAM,gBAAgB;AAEtB,MAAI;GACF,MAAM,EAAE,wBAAwB,MAAM,OAAO;GAC7C,MAAM,EAAE,eAAe,MAAM,OAAO;GACpC,MAAM,EAAE,YAAY,MAAM,OAAO;GACjC,MAAM,EAAE,mBAAmB,MAAM,OAAO;GACxC,MAAM,EAAE,2BAA2B,MAAM,OAAO;GAChD,MAAM,EAAE,6BAA6B,MAAM,OAAO;GAElD,MAAM,WAAW,WAAW,YAAY,WAAW;GAEnD,MAAM,UAAU,oBAAoB,EAClC,UAAU,GACP,WAAW,EACV,WAAW,oBAAoB,KAAK,kBACrC,EACF,EACF,CAAC;GAEF,MAAM,SAAS,MAAM,QAAQ,UAAU,UAAU,WAAW,OAAO;AAEnE,aAAU,YAAY;AACpB,QAAI,UAAU,OAAQ,OAAe,YAAY,WAC/C,OAAO,OAAe,SAAS;AAEjC,QAAI,WAAW,OAAQ,QAAgB,YAAY,WACjD,OAAO,QAAgB,SAAS;AAElC,aAAS,MAAM;AACf,aAAS,MAAM;AACf,QAAI,UAAU,IAAI,OAAO,SACvB,WAAU,IAAI,OAAO,WAAW;;AAKpC,YAAS,MAAM,IAAI,WAAW,OAAO,QAAQ,EAC3C,cAAc,CACZ,SAAS,UAAe;AACtB,YAAQ,MAAM,iBAAiB,MAAM;KACrC,CACH,EACF,CAAC;AAIF,YAAS,MAAM,IAAI,eAAe,OAAO,QAAQ;IAC/C,SAAS,CACP,IAAI,uBAAuB,EACzB,kBAAkB,CAAC,IAAI,0BAA0B,CAAC,EACnD,CAAC,CACH;IACD,cAAc,CACZ,SAAS,UAAe;AACtB,aAAQ,MAAM,qBAAqB,MAAM;MACzC,CACH;IACF,CAAC;AAEF,WAAQ,IAAI,iDAAiD;AAC7D,WAAQ,IAAI,iCAAiC;AAC7C,WAAQ,IAAI,iDAAiD;AAC7D,WAAQ,IAAI,kCAAkC,KAAK,UAAU;AAC7D,WAAQ,IAAI,kCAAkC,KAAK,MAAM;AACzD,WAAQ,IAAI,kCAAkC,KAAK,GAAG;AACtD,WAAQ,IAAI,iDAAiD;AAE7D,aAAU,IAAI,OAAO,WAAW;AAEhC,OAAI,UAAU,OACZ,WAAU,OAAO,KAAK,SAAS,YAAY;AACzC,UAAM,gBAAgB;KACtB;WAEG,OAAO;AACd,WAAQ,MAAM,4BAA4B,MAAM;AAChD,SAAM,gBAAgB;;KAEtB;AAEJ,SAAQ,KAAK,UAAU,YAAY;AACjC,QAAM,gBAAgB;GACtB;AACF,SAAQ,KAAK,WAAW,YAAY;AAClC,QAAM,gBAAgB;GACtB;AAGF,WAAU,IAAI,IAAI,MAAM,KAAU,QAAa;AAC7C,MAAI,KAAK;GACP,IAAI;GACJ,QAAQ,WAAW;GACnB,SAAS,WAAW;GACpB,QAAQ,UAAU,IAAI,OAAO,UAAU,MAAM,UAAU;GACvD,WAAW;IACT,QAAQ;IACR,MAAM;IACN,KAAK;IACN;GACF,CAAC;GACF;CAGF,MAAM,mBAAmB,OAAO,KAAU,QAAa;EACrD,MAAM,aAAa,UAAU,IAAI,OAAO,UAAU;AAClD,MAAI,CAAC,WACH,QAAO,IAAI,OAAO,IAAI,CAAC,KAAK,EAAE,OAAO,2BAA2B,CAAC;AAGnE,MAAI;GACF,MAAM,MAAM,UAAU,IAAI,QAAQ,OAAO,IAAI;GAC7C,MAAM,aAAa,IAAI,QAAQ,KAAK;IAClC,QAAQ,IAAI;IACZ,SAAS,IAAI;IACb,MAAM,IAAI,WAAW,SAAS,IAAI,WAAW,SAAS,MAAM;IAC7D,CAAC;GAEF,MAAM,SAAS,MAAM,WAAW,OAAO,YAAY;IACjD,QAAQ;IACR,SAAS,EAAE;IACZ,CAAC;AAEF,OAAI,OAAO,UAAU;AACnB,QAAI,OAAO,OAAO,SAAS,OAAO;AAClC,WAAO,SAAS,QAAQ,SAAS,OAAe,QAAgB;AAC9D,SAAI,UAAU,KAAK,MAAM;MACzB;IACF,MAAM,OAAO,MAAM,OAAO,SAAS,MAAM;AACzC,QAAI,KAAK,KAAK;SAEd,KAAI,OAAO,IAAI,CAAC,KAAK,YAAY;WAE5B,OAAO;AACd,WAAQ,MAAM,kBAAkB,MAAM;AACtC,OAAI,OAAO,IAAI,CAAC,KAAK,EAAE,OAAQ,MAAgB,SAAS,CAAC;;;AAI7D,WAAU,IAAI,IAAI,QAAQ,iBAAiB;AAC3C,WAAU,IAAI,IAAI,UAAU,iBAAiB;AAG7C,WAAU,IAAI,IAAI,cAAc,OAAO,KAAU,QAAa;EAC5D,MAAM,aAAa,UAAU,IAAI,OAAO,UAAU;AAClD,MAAI,CAAC,WACH,QAAO,IAAI,OAAO,IAAI,CAAC,KAAK,EAAE,OAAO,2BAA2B,CAAC;AAGnE,MAAI;GACF,MAAM,MAAM,UAAU,IAAI,QAAQ,OAAO,IAAI;GAC7C,MAAM,aAAa,IAAI,QAAQ,KAAK;IAClC,QAAQ,IAAI;IACZ,SAAS,IAAI;IACb,MAAM,IAAI,WAAW,SAAS,IAAI,WAAW,SAAS,MAAM;IAC7D,CAAC;GAEF,MAAM,SAAS,MAAM,WAAW,OAAO,YAAY;IACjD,QAAQ;IACR,SAAS,EAAE;IACZ,CAAC;AAEF,OAAI,OAAO,UAAU;AACnB,QAAI,OAAO,OAAO,SAAS,OAAO;AAClC,WAAO,SAAS,QAAQ,SAAS,OAAe,QAAgB;AAC9D,SAAI,UAAU,KAAK,MAAM;MACzB;IACF,MAAM,OAAO,MAAM,OAAO,SAAS,MAAM;AACzC,QAAI,KAAK,KAAK;SAEd,KAAI,OAAO,IAAI,CAAC,KAAK,YAAY;WAE5B,OAAO;AACd,WAAQ,MAAM,cAAc,MAAM;AAClC,OAAI,OAAO,IAAI,CAAC,KAAK,EAAE,OAAQ,MAAgB,SAAS,CAAC;;GAE3D;;;;;AC/KJ,IAAa,uBAAb,MAAkE;CAChE,OAAO;CAEP,YAAY,AAAQC,UAA8B,EAAE,EAAE;EAAlC;;CAEpB,MAAM,UAAoB;EAExB,MAAM,aAAa,cAAc,SAAS,QAAQ,WAAW,QAAQ,KAAK,CAAC;EAC3E,MAAM,YAAY,cAAc,KAAK,QAAQ,iBAAiB,kBAAkB;EAChF,MAAM,OAAO,KAAK,QAAQ,QAAQ,WAAW,QAAQ;AAGrD,OAAK,kBAAkB,UAAU,WAAW;AAG5C,MAAI,CAAC,SAAS,QAAQ,UACpB,UAAS,QAAQ,YAAY,EAAE;AAIjC,OAAK,mBAAmB,UAAU,YAAY,WAAW,KAAK;AAG9D,MAAI,OAAO,UAAU,uBAAuB;GAC1C,MAAM,WAAW;GACjB,UAAU;GACV,gBAAgB,WACN,QAAQ,wCAAwC,CACzD;GACD,SAAS,EAAE,MAAM,mBAAmB;GACpC,SAAS,EACP,YAAY,kBACb;GACD,QAAQ,wBAAwB,WAAW;GAC5C,CAAC,CAAC,MAAM,SAAS;;CAGpB,AAAQ,kBAAkB,UAAoB,YAAiB;EAC7D,MAAM,UAAU,SAAS,QAAQ,WAAW,QAAQ,KAAK;AAGzD,MAAI,CAAC,SAAS,QAAQ,OACpB,UAAS,QAAQ,SAAS,EAAE;AAE9B,WAAS,QAAQ,OAAO,aAAa,WAAW;AAChD,WAAS,QAAQ,OAAO,aAAa;AACrC,WAAS,QAAQ,OAAO,OAAO,KAAK,QAAQ,SAAS,OAAO;AAC5D,WAAS,QAAQ,OAAO,QAAQ;AAChC,WAAS,QAAQ,OAAO,UAAU,EAAE,MAAM,mBAAmB;AAG7D,MAAI,CAAC,SAAS,QAAQ,MACpB,UAAS,QAAQ,QAAQ,EACvB,MAAM,EACJ,QAAQ,CAAC,cAAc,EACxB,EACF;AAIH,MAAI,CAAC,SAAS,QAAQ,OACpB,UAAS,QAAQ,SAAS;AAG5B,MAAI,CAAC,SAAS,QAAQ,KACpB,UAAS,QAAQ,OAAO,QAAQ,IAAI,aAAa,gBAAgB,gBAAgB;AAInF,MAAI,CAAC,SAAS,QAAQ,QACpB,UAAS,QAAQ,UAAU;AAI7B,MAAI,CAAC,SAAS,QAAQ,sBACpB,UAAS,QAAQ,wBAAwB,EACvC,OAAO,QACR;AAIH,OAAK,uBAAuB,SAAS;AAGrC,MAAI,CAAC,SAAS,QAAQ,QACpB,UAAS,QAAQ,UAAU,EAAE;AAE/B,WAAS,QAAQ,QAAQ,aAAa;GAAC;GAAO;GAAQ;GAAM;;CAG9D,AAAQ,uBAAuB,UAAoB;AACjD,MAAI,CAAC,SAAS,QAAQ,OACpB,UAAS,QAAQ,SAAS,EAAE,OAAO,EAAE,EAAE;AAGzC,MAAI,CAAC,SAAS,QAAQ,OAAO,MAC3B,UAAS,QAAQ,OAAO,QAAQ,EAAE;AAapC,MAAI,CATgB,SAAS,QAAQ,OAAO,MAAM,MAAM,SACtD,OAAO,SAAS,YAChB,SAAS,QACT,UAAU,QACV,KAAK,gBAAgB,UACrB,KAAK,KAAK,KAAK,MAAM,CACtB,CAIC,UAAS,QAAQ,OAAO,MAAM,KAAK;GACjC,MAAM;GACN,KAAK;GACL,SAAS;GACV,CAAC;;CAIN,AAAQ,mBAAmB,UAAoB,YAAiB,WAAgB,MAAc;AAC5F,MAAI,CAAC,SAAS,QAAQ,UACpB;EAGF,MAAM,UAAU,SAAS,QAAQ,WAAW,QAAQ,KAAK;EACzD,MAAM,gBAAgB,SAAS,QAAQ,UAAU;AAEjD,WAAS,QAAQ,UAAU,OAAO;AAClC,WAAS,QAAQ,UAAU,SAAS,KAAK,KAAK,SAAS,OAAO;AAC9D,WAAS,QAAQ,UAAU,MAAM;AACjC,WAAS,QAAQ,UAAU,gBAAgB,EAAE,aAAa,MAAM;AAChE,WAAS,QAAQ,UAAU,UAAU;GACnC,+BAA+B;GAC/B,gCAAgC;GAChC,gCAAgC;GACjC;AAGD,WAAS,QAAQ,UAAU,SAAS;GAClC,SAAS;GACT,SAAS;IACP,UAAU;IACV,QAAQ;IACT;GACF;AAED,WAAS,QAAQ,UAAU,oBAAoB,aAAa,cAAc;AACxE,yBAAsB,WAAW,YAAY,WAAW,KAAK;AAC7D,UAAO,gBAAgB,cAAc,aAAa,UAAU,GAAG"}

package/dist/chunk-QQAxy9l9.mjs

@@ -0,0 +1,31 @@
+import { createRequire } from "node:module";
+
+//#region rolldown:runtime
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __commonJS = (cb, mod) => function() {
+	return mod || (0, cb[__getOwnPropNames(cb)[0]])((mod = { exports: {} }).exports, mod), mod.exports;
+};
+var __copyProps = (to, from, except, desc) => {
+	if (from && typeof from === "object" || typeof from === "function") for (var keys = __getOwnPropNames(from), i = 0, n = keys.length, key; i < n; i++) {
+		key = keys[i];
+		if (!__hasOwnProp.call(to, key) && key !== except) __defProp(to, key, {
+			get: ((k) => from[k]).bind(null, key),
+			enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable
+		});
+	}
+	return to;
+};
+var __reExport = (target, mod, secondTarget) => (__copyProps(target, mod, "default"), secondTarget && __copyProps(secondTarget, mod, "default"));
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", {
+	value: mod,
+	enumerable: true
+}) : target, mod));
+var __require = /* @__PURE__ */ createRequire(import.meta.url);
+
+//#endregion
+export { __toESM as i, __reExport as n, __require as r, __commonJS as t };

package/dist/chunk-zltIcp7o.cjs

@@ -0,0 +1,46 @@
+//#region rolldown:runtime
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __commonJS = (cb, mod) => function() {
+	return mod || (0, cb[__getOwnPropNames(cb)[0]])((mod = { exports: {} }).exports, mod), mod.exports;
+};
+var __copyProps = (to, from, except, desc) => {
+	if (from && typeof from === "object" || typeof from === "function") for (var keys = __getOwnPropNames(from), i = 0, n = keys.length, key; i < n; i++) {
+		key = keys[i];
+		if (!__hasOwnProp.call(to, key) && key !== except) __defProp(to, key, {
+			get: ((k) => from[k]).bind(null, key),
+			enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable
+		});
+	}
+	return to;
+};
+var __reExport = (target, mod, secondTarget) => (__copyProps(target, mod, "default"), secondTarget && __copyProps(secondTarget, mod, "default"));
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", {
+	value: mod,
+	enumerable: true
+}) : target, mod));
+
+//#endregion
+
+Object.defineProperty(exports, '__commonJS', {
+  enumerable: true,
+  get: function () {
+    return __commonJS;
+  }
+});
+Object.defineProperty(exports, '__reExport', {
+  enumerable: true,
+  get: function () {
+    return __reExport;
+  }
+});
+Object.defineProperty(exports, '__toESM', {
+  enumerable: true,
+  get: function () {
+    return __toESM;
+  }
+});

package/dist/effect.cjs

@@ -0,0 +1,9 @@
+
+
+var effect = require("effect");
+Object.keys(effect).forEach(function (k) {
+  if (k !== 'default' && !Object.prototype.hasOwnProperty.call(exports, k)) Object.defineProperty(exports, k, {
+    enumerable: true,
+    get: function () { return effect[k]; }
+  });
+});

package/dist/effect.d.cts

@@ -0,0 +1 @@
+export * from "effect";

package/dist/effect.d.mts

@@ -0,0 +1 @@
+export * from "effect";

package/dist/effect.mjs

@@ -0,0 +1,3 @@
+export * from "effect"
+
+export {  };

package/dist/errors-CVnoPl9v.cjs

@@ -0,0 +1,68 @@
+const require_zod = require('./zod-DYghWCz1.cjs');
+
+//#region src/errors.ts
+/**
+* Common error schemas for plugin contracts.
+* Import these to ensure consistent error handling across plugins.
+*
+* @example
+* ```typescript
+* import { CommonPluginErrors } from "every-plugin/errors";
+*
+* export const contract = oc.router({
+*   getData: oc.route(...)
+*     .errors(CommonPluginErrors)
+* });
+* ```
+*/
+const CommonPluginErrors = {
+	UNAUTHORIZED: { data: require_zod.zod_exports.z.object({
+		apiKeyProvided: require_zod.zod_exports.z.boolean(),
+		provider: require_zod.zod_exports.z.string().optional(),
+		authType: require_zod.zod_exports.z.enum([
+			"apiKey",
+			"oauth",
+			"token"
+		]).optional()
+	}) },
+	RATE_LIMITED: { data: require_zod.zod_exports.z.object({
+		retryAfter: require_zod.zod_exports.z.number().int().min(1),
+		remainingRequests: require_zod.zod_exports.z.number().int().min(0).optional(),
+		resetTime: require_zod.zod_exports.z.string().datetime().optional(),
+		limitType: require_zod.zod_exports.z.enum([
+			"requests",
+			"tokens",
+			"bandwidth"
+		]).optional()
+	}) },
+	SERVICE_UNAVAILABLE: { data: require_zod.zod_exports.z.object({
+		retryAfter: require_zod.zod_exports.z.number().int().optional(),
+		maintenanceWindow: require_zod.zod_exports.z.boolean().default(false),
+		estimatedUptime: require_zod.zod_exports.z.string().datetime().optional()
+	}) },
+	BAD_REQUEST: { data: require_zod.zod_exports.z.object({
+		invalidFields: require_zod.zod_exports.z.array(require_zod.zod_exports.z.string()).optional(),
+		validationErrors: require_zod.zod_exports.z.array(require_zod.zod_exports.z.object({
+			field: require_zod.zod_exports.z.string(),
+			message: require_zod.zod_exports.z.string(),
+			code: require_zod.zod_exports.z.string().optional()
+		})).optional()
+	}) },
+	NOT_FOUND: { data: require_zod.zod_exports.z.object({
+		resource: require_zod.zod_exports.z.string().optional(),
+		resourceId: require_zod.zod_exports.z.string().optional()
+	}) },
+	FORBIDDEN: { data: require_zod.zod_exports.z.object({
+		requiredPermissions: require_zod.zod_exports.z.array(require_zod.zod_exports.z.string()).optional(),
+		action: require_zod.zod_exports.z.string().optional()
+	}) }
+};
+
+//#endregion
+Object.defineProperty(exports, 'CommonPluginErrors', {
+  enumerable: true,
+  get: function () {
+    return CommonPluginErrors;
+  }
+});
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,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

package/dist/errors-Car4tFVP.d.mts

@@ -0,0 +1,75 @@
+import { t as zod_d_exports } from "./zod-D4CFw8d9.mjs";
+
+//#region src/errors.d.ts
+
+/**
+ * Common error schemas for plugin contracts.
+ * Import these to ensure consistent error handling across plugins.
+ *
+ * @example
+ * ```typescript
+ * import { CommonPluginErrors } from "every-plugin/errors";
+ *
+ * export const contract = oc.router({
+ *   getData: oc.route(...)
+ *     .errors(CommonPluginErrors)
+ * });
+ * ```
+ */
+declare const CommonPluginErrors: {
+  readonly UNAUTHORIZED: {
+    readonly data: zod_d_exports.z.ZodObject<{
+      apiKeyProvided: zod_d_exports.z.ZodBoolean;
+      provider: zod_d_exports.z.ZodOptional<zod_d_exports.z.ZodString>;
+      authType: zod_d_exports.z.ZodOptional<zod_d_exports.z.ZodEnum<{
+        apiKey: "apiKey";
+        oauth: "oauth";
+        token: "token";
+      }>>;
+    }, zod_d_exports.z.core.$strip>;
+  };
+  readonly RATE_LIMITED: {
+    readonly data: zod_d_exports.z.ZodObject<{
+      retryAfter: zod_d_exports.z.ZodNumber;
+      remainingRequests: zod_d_exports.z.ZodOptional<zod_d_exports.z.ZodNumber>;
+      resetTime: zod_d_exports.z.ZodOptional<zod_d_exports.z.ZodString>;
+      limitType: zod_d_exports.z.ZodOptional<zod_d_exports.z.ZodEnum<{
+        requests: "requests";
+        tokens: "tokens";
+        bandwidth: "bandwidth";
+      }>>;
+    }, zod_d_exports.z.core.$strip>;
+  };
+  readonly SERVICE_UNAVAILABLE: {
+    readonly data: zod_d_exports.z.ZodObject<{
+      retryAfter: zod_d_exports.z.ZodOptional<zod_d_exports.z.ZodNumber>;
+      maintenanceWindow: zod_d_exports.z.ZodDefault<zod_d_exports.z.ZodBoolean>;
+      estimatedUptime: zod_d_exports.z.ZodOptional<zod_d_exports.z.ZodString>;
+    }, zod_d_exports.z.core.$strip>;
+  };
+  readonly BAD_REQUEST: {
+    readonly data: zod_d_exports.z.ZodObject<{
+      invalidFields: zod_d_exports.z.ZodOptional<zod_d_exports.z.ZodArray<zod_d_exports.z.ZodString>>;
+      validationErrors: zod_d_exports.z.ZodOptional<zod_d_exports.z.ZodArray<zod_d_exports.z.ZodObject<{
+        field: zod_d_exports.z.ZodString;
+        message: zod_d_exports.z.ZodString;
+        code: zod_d_exports.z.ZodOptional<zod_d_exports.z.ZodString>;
+      }, zod_d_exports.z.core.$strip>>>;
+    }, zod_d_exports.z.core.$strip>;
+  };
+  readonly NOT_FOUND: {
+    readonly data: zod_d_exports.z.ZodObject<{
+      resource: zod_d_exports.z.ZodOptional<zod_d_exports.z.ZodString>;
+      resourceId: zod_d_exports.z.ZodOptional<zod_d_exports.z.ZodString>;
+    }, zod_d_exports.z.core.$strip>;
+  };
+  readonly FORBIDDEN: {
+    readonly data: zod_d_exports.z.ZodObject<{
+      requiredPermissions: zod_d_exports.z.ZodOptional<zod_d_exports.z.ZodArray<zod_d_exports.z.ZodString>>;
+      action: zod_d_exports.z.ZodOptional<zod_d_exports.z.ZodString>;
+    }, zod_d_exports.z.core.$strip>;
+  };
+};
+//#endregion
+export { CommonPluginErrors as t };
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiZXJyb3JzLUNhcjR0RlZQLmQubXRzIiwibmFtZXMiOltdLCJzb3VyY2VzIjpbIi4uL3NyYy9lcnJvcnMudHMiXSwic291cmNlc0NvbnRlbnQiOltdLCJtYXBwaW5ncyI6Ijs7Ozs7O0FBZ0JBOzs7Ozs7Ozs7Ozs7Y0FBYSJ9