@cordy/electro-generator 1.0.0

package/dist/index.d.mts

@@ -0,0 +1,76 @@
+import { WindowDefinition } from "@cordy/electro";
+
+//#region src/types.d.ts
+/**
+* Codegen scan result types.
+*
+* These are the shapes the AST scanner produces and the generator consumes.
+* First iteration uses method names only — full type extraction is future work.
+*/
+interface ScannedService {
+  id: string;
+  scope: string;
+  methods: string[];
+  filePath: string;
+  varName: string;
+  exported: boolean;
+}
+interface ScannedTask {
+  id: string;
+  varName: string;
+  filePath: string;
+  exported: boolean;
+}
+interface ScannedEvent {
+  id: string;
+  varName: string;
+  filePath: string;
+  exported: boolean;
+}
+interface ScannedFeature {
+  id: string;
+  filePath: string;
+  dependencies: string[];
+  services: ScannedService[];
+  tasks: ScannedTask[];
+  events: ScannedEvent[];
+  publishedEvents: string[];
+}
+interface ScanResult {
+  features: ScannedFeature[];
+}
+interface GeneratedFile {
+  path: string;
+  content: string;
+}
+//#endregion
+//#region src/generator.d.ts
+interface GeneratorInput {
+  scanResult: ScanResult;
+  windows: readonly WindowDefinition[];
+  /** Root output directory (e.g. `.electro/`). Generated files go into `generated/` subdirectory. */
+  outputDir: string;
+  /** Source directory where `electro-env.d.ts` will be written (e.g. `src/`). */
+  srcDir: string;
+}
+interface GeneratorOutput {
+  /** Files to write into `outputDir` (generated preload scripts, bridge types). */
+  files: GeneratedFile[];
+  /** Feature registry types file to write into `srcDir`. */
+  envTypes: GeneratedFile;
+}
+/**
+* Generate all output files from scan results and window definitions.
+*/
+declare function generate(input: GeneratorInput): GeneratorOutput;
+//#endregion
+//#region src/scanner.d.ts
+/**
+* Scan TypeScript source files and extract feature/service metadata.
+*
+* @param basePath - Root directory to scan (e.g., `./src`)
+* @returns Aggregated scan result with all discovered features and services.
+*/
+declare function scan(basePath: string): Promise<ScanResult>;
+//#endregion
+export { type GeneratedFile, type GeneratorInput, type GeneratorOutput, type ScanResult, type ScannedFeature, type ScannedService, type ScannedTask, generate, scan };

package/dist/index.mjs

@@ -0,0 +1,605 @@
+import { dirname, join, relative } from "node:path";
+import { PolicyEngine } from "@cordy/electro";
+import { readFileSync } from "node:fs";
+import { Visitor, parseSync } from "oxc-parser";
+
+//#region src/generator.ts
+/**
+* Code Generator — produces preload scripts, bridge types, and context types.
+*
+* Takes a ScanResult + window definitions and emits generated files.
+* Uses PolicyEngine for deny-by-default per-window filtering.
+*/
+const HEADER = "// Auto-generated by Electro codegen. Do not edit.\n";
+/** Quote a property key if it's not a valid JS identifier. */
+function q(name) {
+	return /^[a-zA-Z_$][a-zA-Z0-9_$]*$/.test(name) ? name : `"${name}"`;
+}
+/**
+* Build the IPC stub expression for a single method.
+* Format: `(...args: unknown[]) => ipcRenderer.invoke("feature:service:method", ...args)`
+*/
+function methodStub(featureId, serviceId, method) {
+	return `(...args: unknown[]) => ipcRenderer.invoke("${`${featureId}:${serviceId}:${method}`}", ...args)`;
+}
+/**
+* Generate a preload script for a specific window.
+*
+* Structure: `window.electro.{featureId}.{serviceId}.{method}()`
+* Only EXPOSED scope services are included.
+*/
+function generatePreload(windowName, features, policy, preloadExtension) {
+	const allowedFeatures = features.filter((f) => policy.canAccess(windowName, f.id));
+	const featureEntries = [];
+	for (const feature of allowedFeatures) {
+		const exposedServices = feature.services.filter((s) => s.scope === "exposed");
+		if (exposedServices.length === 0) {
+			featureEntries.push(`    ${q(feature.id)}: {},`);
+			continue;
+		}
+		const serviceEntries = [];
+		for (const service of exposedServices) {
+			if (service.methods.length === 0) {
+				serviceEntries.push(`        ${q(service.id)}: {},`);
+				continue;
+			}
+			const methodEntries = service.methods.map((m) => `            ${q(m)}: ${methodStub(feature.id, service.id, m)},`).join("\n");
+			serviceEntries.push(`        ${q(service.id)}: {\n${methodEntries}\n        },`);
+		}
+		featureEntries.push(`    ${q(feature.id)}: {\n${serviceEntries.join("\n")}\n    },`);
+	}
+	let content = `${HEADER}
+import { contextBridge, ipcRenderer } from "electron";
+
+contextBridge.exposeInMainWorld("electro", ${featureEntries.length > 0 ? `{\n${featureEntries.join("\n")}\n}` : "{}"});
+`;
+	if (preloadExtension) content += `\n// User extension\nimport "${preloadExtension}";\n`;
+	return {
+		path: `generated/preload/${windowName}.gen.ts`,
+		content
+	};
+}
+/**
+* Generate bridge type declarations for a specific window.
+* Makes `window.electro` type-safe in the renderer.
+*/
+function generateBridgeTypes(windowName, features, policy) {
+	const allowedFeatures = features.filter((f) => policy.canAccess(windowName, f.id));
+	const featureTypes = [];
+	for (const feature of allowedFeatures) {
+		const exposedServices = feature.services.filter((s) => s.scope === "exposed");
+		if (exposedServices.length === 0) {
+			featureTypes.push(`        ${q(feature.id)}: Record<string, never>;`);
+			continue;
+		}
+		const serviceTypes = [];
+		for (const service of exposedServices) {
+			if (service.methods.length === 0) {
+				serviceTypes.push(`            ${q(service.id)}: Record<string, never>;`);
+				continue;
+			}
+			const methodTypes = service.methods.map((m) => `                ${q(m)}(...args: unknown[]): Promise<unknown>;`).join("\n");
+			serviceTypes.push(`            ${q(service.id)}: {\n${methodTypes}\n            };`);
+		}
+		featureTypes.push(`        ${q(feature.id)}: {\n${serviceTypes.join("\n")}\n        };`);
+	}
+	const content = `${HEADER}
+export interface ElectroBridge ${featureTypes.length > 0 ? `{\n${featureTypes.join("\n")}\n    }` : "Record<string, never>"}
+
+declare global {
+    interface Window {
+        electro: ElectroBridge;
+    }
+}
+`;
+	return {
+		path: `generated/windows/${windowName}.bridge.d.ts`,
+		content
+	};
+}
+/** Calculate the import path from the generated env types file to a source file. */
+function toImportPath(envTypesDir, sourceFilePath) {
+	const importPath = relative(dirname(join(envTypesDir, "electro-env.d.ts")), sourceFilePath).replace(/\.ts$/, "");
+	return importPath.startsWith(".") ? importPath : `./${importPath}`;
+}
+const FEATURE_TYPES_HEADER = `// Auto-generated by Electro codegen. Do not edit.
+// Feature context types — provides IDE completions for getService/getTask/getFeature.
+
+export {};
+
+/* ── Utility types ────────────────────────────────────── */
+type _SvcApi<T> = T extends { api(): infer R } ? NonNullable<R> : never;
+type _TaskPayload<T> = T extends { start(payload?: infer P): any } ? P : void;
+type _EventPayload<T> = T extends { payload(): infer P } ? P : unknown;
+`;
+/**
+* Generate feature type declarations for the main process.
+* Emits a single FeatureMap interface with per-feature entries for
+* services, tasks, and dependencies. Uses typeof import() for full type inference.
+*/
+function generateWindowTypes(windows) {
+	if (windows.length === 0) return "";
+	const entries = [];
+	for (const win of windows) {
+		const electronType = (win.type ?? "base-window") === "browser-window" ? "import(\"electron\").BrowserWindow" : "import(\"electron\").BaseWindow";
+		entries.push(`        "${win.name}": ${electronType};`);
+	}
+	return `\n    interface WindowMap {\n${entries.join("\n")}\n    }\n`;
+}
+function generateFeatureTypes(features, srcDir, windows) {
+	const seenFeatures = /* @__PURE__ */ new Set();
+	const featureBlocks = [];
+	const svcOwnerEntries = [];
+	const taskOwnerEntries = [];
+	for (const feature of features) {
+		if (seenFeatures.has(feature.id)) {
+			console.warn(`[generator] Duplicate feature id "${feature.id}" — first wins`);
+			continue;
+		}
+		seenFeatures.add(feature.id);
+		const seenServices = /* @__PURE__ */ new Set();
+		const serviceEntries = [];
+		for (const svc of feature.services) {
+			if (seenServices.has(svc.id)) {
+				console.warn(`[generator] Duplicate service id "${svc.id}" in feature "${feature.id}" — first wins`);
+				continue;
+			}
+			seenServices.add(svc.id);
+			svcOwnerEntries.push(`        "${svc.id}": "${feature.id}";`);
+			if (svc.exported) {
+				const importPath = toImportPath(srcDir, svc.filePath);
+				serviceEntries.push(`                "${svc.id}": _SvcApi<typeof import("${importPath}").${svc.varName}>;`);
+			} else serviceEntries.push(`                "${svc.id}": unknown;`);
+		}
+		const seenTasks = /* @__PURE__ */ new Set();
+		const taskEntries = [];
+		for (const task of feature.tasks) {
+			if (seenTasks.has(task.id)) {
+				console.warn(`[generator] Duplicate task id "${task.id}" in feature "${feature.id}" — first wins`);
+				continue;
+			}
+			seenTasks.add(task.id);
+			taskOwnerEntries.push(`        "${task.id}": "${feature.id}";`);
+			if (task.exported) {
+				const importPath = toImportPath(srcDir, task.filePath);
+				taskEntries.push(`                "${task.id}": _TaskPayload<typeof import("${importPath}").${task.varName}>;`);
+			} else taskEntries.push(`                "${task.id}": void;`);
+		}
+		const seenEvents = /* @__PURE__ */ new Set();
+		const eventEntries = [];
+		for (const evt of feature.events ?? []) {
+			if (seenEvents.has(evt.id)) {
+				console.warn(`[generator] Duplicate event id "${evt.id}" in feature "${feature.id}" — first wins`);
+				continue;
+			}
+			seenEvents.add(evt.id);
+			if (evt.exported) {
+				const importPath = toImportPath(srcDir, evt.filePath);
+				eventEntries.push(`                "${evt.id}": _EventPayload<typeof import("${importPath}").${evt.varName}>;`);
+			} else eventEntries.push(`                "${evt.id}": unknown;`);
+		}
+		const deps = feature.dependencies ?? [];
+		const depsType = deps.length > 0 ? deps.map((d) => `"${d}"`).join(" | ") : "never";
+		const svcBody = serviceEntries.length > 0 ? `{\n${serviceEntries.join("\n")}\n            }` : "{}";
+		const taskBody = taskEntries.length > 0 ? `{\n${taskEntries.join("\n")}\n            }` : "{}";
+		const eventBody = eventEntries.length > 0 ? `{\n${eventEntries.join("\n")}\n            }` : "{}";
+		featureBlocks.push(`        "${feature.id}": {
+            services: ${svcBody};
+            tasks: ${taskBody};
+            events: ${eventBody};
+            dependencies: ${depsType};
+        };`);
+	}
+	return {
+		path: "electro-env.d.ts",
+		content: `${FEATURE_TYPES_HEADER}
+declare module "@cordy/electro" {
+    interface FeatureMap ${featureBlocks.length > 0 ? `{\n${featureBlocks.join("\n")}\n    }` : "{}"}
+
+    interface ServiceOwnerMap ${svcOwnerEntries.length > 0 ? `{\n${svcOwnerEntries.join("\n")}\n    }` : "{}"}
+
+    interface TaskOwnerMap ${taskOwnerEntries.length > 0 ? `{\n${taskOwnerEntries.join("\n")}\n    }` : "{}"}
+${generateWindowTypes(windows)}}
+`
+	};
+}
+/**
+* Generate all output files from scan results and window definitions.
+*/
+function generate(input) {
+	const { scanResult, windows, outputDir, srcDir } = input;
+	const policy = new PolicyEngine(windows);
+	const files = [];
+	for (const win of windows) {
+		const knownIds = new Set(scanResult.features.map((f) => f.id));
+		for (const fId of win.features ?? []) if (!knownIds.has(fId)) console.warn(`[generator] Window "${win.name}" references unknown feature "${fId}"`);
+		files.push(generatePreload(win.name, scanResult.features, policy, win.preload));
+		files.push(generateBridgeTypes(win.name, scanResult.features, policy));
+	}
+	return {
+		files,
+		envTypes: generateFeatureTypes(scanResult.features, srcDir, windows)
+	};
+}
+
+//#endregion
+//#region src/scanner.ts
+/**
+* AST Scanner — OXC-based feature/service discovery.
+*
+* Parses TypeScript source files with OXC and extracts metadata from
+* `createFeature()` and `createService()` calls. Only string literals
+* are extracted; computed or dynamic values are skipped with a warning.
+*
+* Uses node:fs + tinyglobby (cross-runtime: works in Bun and vitest workers).
+*/
+const EXCLUDE_PATTERNS = [
+	/\.d\.ts$/,
+	/\.test\.ts$/,
+	/\.spec\.ts$/,
+	/\.gen\.ts$/
+];
+function shouldInclude(filePath) {
+	return filePath.endsWith(".ts") && !EXCLUDE_PATTERNS.some((p) => p.test(filePath));
+}
+/** Extract a string literal value from an AST node. Returns null for non-literals. */
+function getStringLiteral(node) {
+	if (!node) return null;
+	if (node.type === "Literal" && typeof node.value === "string") return node.value;
+	return null;
+}
+/** Extract an array of string literals from an ArrayExpression node. */
+function getStringArray(node) {
+	if (!node || node.type !== "ArrayExpression") return [];
+	const elements = node.elements;
+	const result = [];
+	for (const el of elements) {
+		const val = getStringLiteral(el);
+		if (val !== null) result.push(val);
+	}
+	return result;
+}
+/** Get a property value from an ObjectExpression by key name. */
+function getObjectProperty(obj, key) {
+	const props = obj.properties;
+	for (const prop of props) {
+		if (prop.type !== "Property") continue;
+		const propKey = prop.key;
+		if (propKey.type === "Identifier" && propKey.name === key) return prop.value;
+	}
+	return null;
+}
+/** Extract property names from an ObjectExpression (method names from api() return). */
+function getPropertyNames(obj) {
+	const props = obj.properties;
+	const names = [];
+	for (const prop of props) {
+		if (prop.type !== "Property") continue;
+		const key = prop.key;
+		if (key.type === "Identifier" && typeof key.name === "string") names.push(key.name);
+	}
+	return names;
+}
+/**
+* Extract method names from the `api` property.
+*
+* Handles:
+* - `api: () => ({ method1() {}, method2() {} })`       — arrow with parens
+* - `api: () => { return { method1() {}, method2() {} } }` — arrow with block
+* - `api(): Type { return { ... } }`                     — method shorthand
+*/
+function extractMethodsFromApi(apiNode) {
+	if (apiNode.type === "ArrowFunctionExpression") {
+		let body = apiNode.body;
+		if (body.type === "ParenthesizedExpression") body = body.expression;
+		if (body.type === "ObjectExpression") return getPropertyNames(body);
+		if (body.type === "BlockStatement") return extractMethodsFromBlock(body);
+	}
+	if (apiNode.type === "FunctionExpression") return extractMethodsFromBlock(apiNode.body);
+	return [];
+}
+/** Find the first return statement with an object literal in a block. */
+function extractMethodsFromBlock(block) {
+	const stmts = block.body;
+	for (const stmt of stmts) if (stmt.type === "ReturnStatement") {
+		const arg = stmt.argument;
+		if (arg?.type === "ObjectExpression") return getPropertyNames(arg);
+	}
+	return [];
+}
+/**
+* Resolve the scope value from an AST node.
+*
+* Handles:
+* - `ServiceScope.EXPOSED` (MemberExpression)
+* - `"exposed"` (string literal)
+*/
+function resolveScope(node) {
+	const literal = getStringLiteral(node);
+	if (literal) return literal;
+	if (node.type === "MemberExpression" && node.computed === false) return {
+		EXPOSED: "exposed",
+		INTERNAL: "internal",
+		PRIVATE: "private"
+	}[node.property.name.toUpperCase()] ?? null;
+	return null;
+}
+/**
+* Extract published event names from a file's AST.
+* Looks for `ctx.events.publish("eventName", ...)` patterns.
+*/
+function extractPublishedEvents(program) {
+	const events = [];
+	new Visitor({ CallExpression(node) {
+		const callee = node.callee;
+		if (callee.type === "MemberExpression" && callee.computed === false && callee.property.type === "Identifier" && callee.property.name === "publish") {
+			const obj = callee.object;
+			if (obj.type === "MemberExpression" && obj.computed === false && obj.property.type === "Identifier" && obj.property.name === "events") {
+				const args = node.arguments;
+				if (args.length > 0) {
+					const eventName = getStringLiteral(args[0]);
+					if (eventName) events.push(eventName);
+				}
+			}
+		}
+	} }).visit(program);
+	return events;
+}
+/**
+* Walk the program body and collect variable names that appear in
+* `export` declarations (ExportNamedDeclaration with VariableDeclaration).
+*/
+function extractExportedNames(program) {
+	const names = /* @__PURE__ */ new Set();
+	const body = program.body;
+	if (!body) return names;
+	for (const node of body) {
+		if (node.type !== "ExportNamedDeclaration") continue;
+		const declaration = node.declaration;
+		if (declaration?.type === "VariableDeclaration") {
+			const declarators = declaration.declarations;
+			for (const decl of declarators) {
+				const id = decl.id;
+				if (id?.type === "Identifier" && typeof id.name === "string") names.add(id.name);
+			}
+		} else if (!declaration) {
+			const specifiers = node.specifiers;
+			if (specifiers) for (const spec of specifiers) {
+				if (spec.type !== "ExportSpecifier") continue;
+				const local = spec.local;
+				if (local?.type === "Identifier" && typeof local.name === "string") names.add(local.name);
+			}
+		}
+	}
+	return names;
+}
+/**
+* Extract createService() calls from a file.
+* Uses VariableDeclarator to capture `const x = createService({...})` patterns.
+* Returns services keyed by their variable name for later resolution.
+*/
+function extractServices(program, filePath, exportedNames) {
+	const services = [];
+	new Visitor({ VariableDeclarator(node) {
+		const init = node.init;
+		if (!init || init.type !== "CallExpression") return;
+		const callee = init.callee;
+		if (callee.type !== "Identifier" || callee.name !== "createService") return;
+		const args = init.arguments;
+		if (args.length < 1 || args[0].type !== "ObjectExpression") return;
+		const config = args[0];
+		const id = getStringLiteral(getObjectProperty(config, "id"));
+		if (!id) {
+			console.warn(`[scanner] Skipping createService() with non-literal id in ${filePath}`);
+			return;
+		}
+		const scopeNode = getObjectProperty(config, "scope");
+		const scope = scopeNode ? resolveScope(scopeNode) : null;
+		if (!scope) {
+			console.warn(`[scanner] Skipping createService("${id}") with unresolvable scope in ${filePath}`);
+			return;
+		}
+		const apiNode = getObjectProperty(config, "api");
+		const methods = apiNode ? extractMethodsFromApi(apiNode) : [];
+		if (apiNode && methods.length === 0) console.warn(`[scanner] createService("${id}") api() didn't return an object literal in ${filePath}`);
+		const idNode = node.id;
+		const varName = idNode.type === "Identifier" && typeof idNode.name === "string" ? idNode.name : id;
+		services.push({
+			varName,
+			service: {
+				id,
+				scope,
+				methods,
+				filePath,
+				varName,
+				exported: exportedNames.has(varName)
+			}
+		});
+	} }).visit(program);
+	return services;
+}
+/**
+* Extract createTask() calls from a file.
+* Uses VariableDeclarator to capture `const x = createTask({...})` patterns.
+* Returns tasks keyed by their variable name for later resolution.
+*/
+function extractTasks(program, filePath, exportedNames) {
+	const tasks = [];
+	new Visitor({ VariableDeclarator(node) {
+		const init = node.init;
+		if (!init || init.type !== "CallExpression") return;
+		const callee = init.callee;
+		if (callee.type !== "Identifier" || callee.name !== "createTask") return;
+		const args = init.arguments;
+		if (args.length < 1 || args[0].type !== "ObjectExpression") return;
+		const config = args[0];
+		const id = getStringLiteral(getObjectProperty(config, "id"));
+		if (!id) {
+			console.warn(`[scanner] Skipping createTask() with non-literal id in ${filePath}`);
+			return;
+		}
+		const idNode = node.id;
+		const varName = idNode.type === "Identifier" && typeof idNode.name === "string" ? idNode.name : id;
+		tasks.push({
+			varName,
+			task: {
+				id,
+				varName,
+				filePath,
+				exported: exportedNames.has(varName)
+			}
+		});
+	} }).visit(program);
+	return tasks;
+}
+/**
+* Extract createEvent() calls from a file.
+* Uses VariableDeclarator to capture `const x = createEvent(...)` patterns.
+*/
+function extractEvents(program, filePath, exportedNames) {
+	const events = [];
+	new Visitor({ VariableDeclarator(node) {
+		const init = node.init;
+		if (!init || init.type !== "CallExpression") return;
+		const callee = init.callee;
+		if (callee.type !== "Identifier" || callee.name !== "createEvent") return;
+		const args = init.arguments;
+		if (args.length < 1) return;
+		const id = getStringLiteral(args[0]);
+		if (!id) {
+			console.warn(`[scanner] Skipping createEvent() with non-literal id in ${filePath}`);
+			return;
+		}
+		const idNode = node.id;
+		const varName = idNode.type === "Identifier" && typeof idNode.name === "string" ? idNode.name : id;
+		events.push({
+			varName,
+			event: {
+				id,
+				varName,
+				filePath,
+				exported: exportedNames.has(varName)
+			}
+		});
+	} }).visit(program);
+	return events;
+}
+/** Extract createFeature() calls from a file. */
+function extractFeatures(program, filePath) {
+	const features = [];
+	const events = extractPublishedEvents(program);
+	new Visitor({ CallExpression(node) {
+		const callee = node.callee;
+		if (callee.type !== "Identifier" || callee.name !== "createFeature") return;
+		const args = node.arguments;
+		if (args.length < 1 || args[0].type !== "ObjectExpression") return;
+		const config = args[0];
+		const id = getStringLiteral(getObjectProperty(config, "id"));
+		if (!id) {
+			console.warn(`[scanner] Skipping createFeature() with non-literal id in ${filePath}`);
+			return;
+		}
+		const dependencies = getStringArray(getObjectProperty(config, "dependencies"));
+		const servicesNode = getObjectProperty(config, "services");
+		const serviceVarNames = [];
+		if (servicesNode?.type === "ArrayExpression") {
+			const elements = servicesNode.elements;
+			for (const el of elements) if (el?.type === "Identifier" && typeof el.name === "string") serviceVarNames.push(el.name);
+		}
+		const tasksNode = getObjectProperty(config, "tasks");
+		const taskVarNames = [];
+		if (tasksNode?.type === "ArrayExpression") {
+			const taskElements = tasksNode.elements;
+			for (const el of taskElements) if (el?.type === "Identifier" && typeof el.name === "string") taskVarNames.push(el.name);
+		}
+		const eventsNode = getObjectProperty(config, "events");
+		const eventVarNames = [];
+		if (eventsNode?.type === "ArrayExpression") {
+			const eventElements = eventsNode.elements;
+			for (const el of eventElements) if (el?.type === "Identifier" && typeof el.name === "string") eventVarNames.push(el.name);
+		}
+		features.push({
+			id,
+			dependencies,
+			serviceVarNames,
+			taskVarNames,
+			eventVarNames,
+			publishedEvents: events,
+			filePath
+		});
+	} }).visit(program);
+	return features;
+}
+async function discoverFiles(basePath) {
+	const { globSync } = await import("tinyglobby");
+	return globSync(["**/*.ts"], {
+		cwd: basePath,
+		absolute: true,
+		ignore: ["node_modules/**"]
+	}).filter(shouldInclude);
+}
+/**
+* Scan TypeScript source files and extract feature/service metadata.
+*
+* @param basePath - Root directory to scan (e.g., `./src`)
+* @returns Aggregated scan result with all discovered features and services.
+*/
+async function scan(basePath) {
+	const files = await discoverFiles(basePath);
+	const allServices = [];
+	const allTasks = [];
+	const allEvents = [];
+	const allFeatures = [];
+	for (const filePath of files) {
+		const result = parseSync(filePath, readFileSync(filePath, "utf-8"), { sourceType: "module" });
+		if (result.errors.length > 0) for (const err of result.errors) console.warn(`[scanner] Parse error in ${filePath}: ${err.message}`);
+		const program = result.program;
+		const exportedNames = extractExportedNames(program);
+		const services = extractServices(program, filePath, exportedNames);
+		const tasks = extractTasks(program, filePath, exportedNames);
+		const events = extractEvents(program, filePath, exportedNames);
+		const features = extractFeatures(program, filePath);
+		allServices.push(...services);
+		allTasks.push(...tasks);
+		allEvents.push(...events);
+		allFeatures.push(...features);
+	}
+	const serviceByVarName = /* @__PURE__ */ new Map();
+	for (const { varName, service } of allServices) serviceByVarName.set(varName, service);
+	const taskByVarName = /* @__PURE__ */ new Map();
+	for (const { varName, task } of allTasks) taskByVarName.set(varName, task);
+	const eventByVarName = /* @__PURE__ */ new Map();
+	for (const { varName, event } of allEvents) eventByVarName.set(varName, event);
+	return { features: allFeatures.map((raw) => {
+		const services = [];
+		for (const varName of raw.serviceVarNames) {
+			const svc = serviceByVarName.get(varName);
+			if (svc) services.push(svc);
+			else console.warn(`[scanner] Feature "${raw.id}" references unknown service variable "${varName}" in ${raw.filePath}`);
+		}
+		const tasks = [];
+		for (const varName of raw.taskVarNames) {
+			const task = taskByVarName.get(varName);
+			if (task) tasks.push(task);
+			else console.warn(`[scanner] Feature "${raw.id}" references unknown task variable "${varName}" in ${raw.filePath}`);
+		}
+		const resolvedEvents = [];
+		for (const varName of raw.eventVarNames) {
+			const evt = eventByVarName.get(varName);
+			if (evt) resolvedEvents.push(evt);
+			else console.warn(`[scanner] Feature "${raw.id}" references unknown event variable "${varName}" in ${raw.filePath}`);
+		}
+		return {
+			id: raw.id,
+			filePath: raw.filePath,
+			dependencies: raw.dependencies,
+			services,
+			tasks,
+			events: resolvedEvents,
+			publishedEvents: raw.publishedEvents
+		};
+	}) };
+}
+
+//#endregion
+export { generate, scan };

package/package.json

@@ -0,0 +1,58 @@
+{
+    "name": "@cordy/electro-generator",
+    "version": "1.0.0",
+    "description": "Code generator for @cordy/electro — scans features and emits preload scripts and bridge types",
+    "license": "MIT",
+    "type": "module",
+    "sideEffects": false,
+    "keywords": [
+        "electron",
+        "codegen",
+        "preload",
+        "bridge",
+        "typescript"
+    ],
+    "repository": {
+        "type": "git",
+        "url": "git+https://github.com/cordy-dev/electro.git",
+        "directory": "packages/electro-generator"
+    },
+    "bugs": {
+        "url": "https://github.com/cordy-dev/electro/issues"
+    },
+    "homepage": "https://github.com/cordy-dev/electro#readme",
+    "publishConfig": {
+        "access": "public"
+    },
+    "engines": {
+        "bun": ">=1.0.0"
+    },
+    "main": "./dist/index.mjs",
+    "types": "./dist/index.d.mts",
+    "files": [
+        "dist"
+    ],
+    "exports": {
+        ".": {
+            "types": "./dist/index.d.mts",
+            "import": "./dist/index.mjs"
+        }
+    },
+    "scripts": {
+        "build": "tsdown",
+        "test": "vitest",
+        "prepublishOnly": "bun run build"
+    },
+    "peerDependencies": {
+        "@cordy/electro": "1.0.0"
+    },
+    "dependencies": {
+        "oxc-parser": "^0.114.0",
+        "tinyglobby": "^0.2.15"
+    },
+    "devDependencies": {
+        "@cordy/electro": "1.0.0",
+        "tsdown": "^0.20.3",
+        "vitest": "v4.1.0-beta.3"
+    }
+}