irgen 0.2.0

package/CHANGELOG.md

@@ -0,0 +1,113 @@
+# Changelog
+
+All notable changes to the `irgen` project will be documented in this file.
+
+## [0.2.0] - 2026-01-11
+
+### General Purpose Frontend & Headless Runtime (Phase 3)
+
+#### Core Architecture
+- **Operation-Oriented Runtime**: Transitioned from a "frontend for a specific backend" to a "general-purpose webapp generator". The runtime now treats **Operations** as the atom of interaction.
+- **Headless Client Runtime**: Implemented a backend-agnostic runtime (`lib/runtime.ts`) that manages operation execution, authentication, and response normalization without being tied to a specific UI framework.
+- **React Hooks Integration**: Introduced `useOperation` and `useResource` hooks for headless interaction, providing built-in loading, error, and data state management.
+- **DataSource Abstraction**: Support for multiple `datasources` with specialized `AuthStrategy`, `EnvelopeAdapter`, and `PaginationAdapter` to connect to any API (REST, GraphQL, etc.).
+
+#### UI & Components
+- **Operation-Bound Components**: Refactored Form and Select components to use the new `useOperation` hook.
+- **Table Component**: New first-class `Table` component with direct binding to operations or resources, featuring premium styling and automatic data fetching.
+- **Multi-App Deployment**: Support for `basePath` in frontend policies and IR, allowing multiple applications (e.g., `PublicSite` and `AdminPortal`) to be routed correctly under different subpaths.
+
+#### DSL Enhancements
+- **Modernized Frontend DSL**: `frontend()` now supports defining entities (`datasources`, `operations`, `resources`) directly via the options object or as standalone function calls within the callback.
+- **Improved Type Safety**: Refined `RuntimeComponent` and DSL helper types for better developer experience.
+
+### Major Features (Phases 9-10)
+
+#### Static-site (HTML-first)
+- **Static-site target**: HTML-first emitter with policy-driven routing, SEO, theming, and asset management.
+- **Progressive enhancements**: Optional sidebar toggle, copy-code, theme toggle, TOC scroll spy, and search.
+- **Code highlighting**: Build-time Shiki highlighting with optional Prism client runtime.
+- **SEO output**: `<title>`, description, canonical, OpenGraph, sitemap, and robots.txt.
+- **Assets**: CSS generation, hashing, public asset passthrough, font preload hints, and CSP meta support.
+- **Search**: Client-side search index + MiniSearch integration (fallback to basic search).
+- **Examples & tests**: Static-site DSL examples and golden test coverage.
+
+#### Frontend & UI
+- **Global Dark Mode**: Implemented a comprehensive dark mode system with a persistent toggle in the main Navbar, `localStorage` state persistence, and adaptive styling for all components (Forms, Marketing, Layouts).
+- **Multi-page SPA Support**: Added full support for complex, multi-page websites via `react-router-dom`, including a high-quality global Navbar and Footer.
+- **Marketing Component Expansion**: Introduced 20+ rich marketing and content components (Hero, Features, Testimonials, FAQ, Logos, CTA, Stats, Timeline) with professional dark mode variants.
+- **Native Syntax Highlighter**: Added a dedicated `CodeBlock` component and `code()` DSL helper, with automatic dependency management (injects `react-syntax-highlighter` into `package.json` only when needed).
+- **Layout Refinement**: Enhanced Tabs, Panels, and Grid components with premium aesthetics, smooth transitions, and better active states.
+
+#### CLI & Engine
+- **CLI Flag: `--outDir`**: Added support for specifying a custom output directory via flag or positional argument.
+- **Improved DSL Loading**: Solved relative import issues when loading DSLs through temporary transpile files by ensuring temp files reside in the same directory as the source.
+- **Robustness**: Fixed interpolation bugs in the React emitter and relaxed Zod validation for internal URLs in form submissions.
+- **Mapping & Lowering**: Updated mapping logic to preserve new component properties (like `codeBlock`) through the lowering pipeline.
+
+#### Rebranding & Identity
+- **Project Renaming**: Officially rebranded from `ir-codegen` to `irgen` for a modern, CLI-friendly identity (consistent with tools like `esbuild` and `vite`).
+- **New Positioning**: Reframed the toolchain as a "compiler-style code generation toolchain built around Intermediate Representation (IR)".
+- **Tagline Update**: Adopted "Compiler-style code generation via Intermediate Representation" as the primary tagline.
+- **Documentation Overhaul**: Updated `README.md` and `ARCHITECTURE.md` to reflect the new policy-driven, compiler-oriented philosophy.
+- **Example Refresh**: Updated `irgen-web.dsl.ts` with the new brand voice and positioning statements.
+
+## [0.1.0] - pre-public history
+
+### Architecture/IR
+- Refined IR layering to match DeclIR → DomainIR → TargetIR: DSL schemas now live under `src/ir/decl/*`, DomainIR files are schema/policy-free, and TargetIR holds emitter-facing policies (backend target now carries `policies.backend.*`).
+- Removed legacy/unified/compat shims in favor of explicit bundle/normalize (`DeclBundle`) aggregation.
+- Mapper/CLI paths always go through bundle → mapper → lowering engine → target transform → emitter; backend target lowering now handles policy defaults/validation.
+- DSL can carry `meta`/`policies` that flow into DeclBundle; CLI merges DSL policies with `--policies` overrides. Extensions can be loaded via CLI `--ext` or programmatic API.
+- CLI: registers built-in mappers before extensions, supports `--ext` loading, defaults to frontend DSL for frontend-like targets (electron/electrobun), prefers frontend loader when those targets requested, and logs actual targets (mode auto when no flag).
+
+### Major Features (Phases 1-8 Completion)
+
+#### Cross-cutting
+- **Backend/Frontend decoupling**: Frontend generation is now driven by its own pipeline (lowering + emitter) and ships with its own `package.json`. Backend generation no longer injects frontend/tailwind dependencies or calls the frontend emitter; running backend and frontend together is an additive choice (run one, the other, or both).
+
+#### Architecture
+- **Generation Gap Pattern**: Refactored backend service generation to separate base classes (auto-generated) from user service implementations (scaffolded once).
+- **Repository Pattern**: Introduced `BaseRepository` and concrete repositories with Dependency Injection (DI) support.
+- **Prisma ORM**: Integrated Prisma as the data layer, replacing in-memory mocks.
+
+#### Backend
+- **Dependency Injection**: Services and Controllers now use constructor injection for better testability.
+- **Extensibility Hooks**: Added `beforeCreate`, `afterCreate`, etc., hooks in `BaseService` for validation and business logic.
+- **Automated Testing**: Integrated `vitest` and auto-generated test files for services.
+
+#### Frontend
+- **SSG/Hybrid Rendering (React)**: Added Vite-based SSG pipeline with SSR bundle + prerender step, manifest-based CSS/JS injection, static HTML output in root `outDir`, and SPA fallback preserved as `index.spa.html`. Hybrid mode hydrates only when needed (currently all routes due to App shell theme toggle).
+- **Tailwind CSS**: Full integration with automated `tailwind.config.js` and `postcss.config.js` generation.
+- **Rich UI Components**:
+  - Form fields now cover text/number/select/textarea/checkbox/radio/date/datetime/time/url/phone/password/daterange, slider, currency, tags/chips, file upload, signature.
+  - Select supports static options and async data sources with search/pagination/debounce, clearable, loading/error skeletons.
+  - Prefix/suffix/tooltip/helpHtml/className for richer templating; icons via Lucide React.
+- **Client-Side Routing**: Transformed frontend output into a Single Page Application (SPA) using `react-router-dom` with auto-generated routes.
+- **Optional PWA Output**: Frontend DSL/policies now accept `pwa.enabled=true` to emit `manifest.webmanifest`, service worker, and icons (defaults remain off).
+- **Vite-Based Frontend Scaffolding**: Generated frontends include Vite config + plugins and ESM-compatible `postcss.config.js`, with entry pointing to `/src/index.tsx`.
+- **React Import Safety**: Generated `App.tsx` explicitly imports React to avoid `React is not defined` when plugins are misconfigured.
+- **Layout & Content Components**: Layout configs (row/column/panel/tabs) now render real child components; content/html blocks; CTA buttons with variants.
+- **Validation & Logic**: JSONLogic-like sandbox (no `Function`), compare fields, min/max for numbers and dates (including date range), email/url built-ins, conditional visible/disabled/required-if, custom logic validators, required/empty checks that understand arrays/objects.
+- **UX & Accessibility**: Async select UX (loading/error/search), multiple select, prefix/suffix/tooltip, aria-labels, error display; loading skeletons for async select.
+- **Submission Pipeline & Actions**: Optional submit config (url/method/success/error messages) with loading/success/error UI, confirm dialog, lifecycle hooks (before/after submit, onSuccess/onError), redirect, draft save (localStorage), mock submit when not configured.
+- **Frontend technical optimizations**:
+  - **Logic Lowering**: Moved complex validation rules, visibility predicates, and computed value logic from React emitters to the lowering stage, reducing runtime overhead and emitter complexity.
+  - **Shared Logic Library**: Extracted common evaluation logic (`evalLogic`, `getByPath`, `isEmptyVal`) into a generated `src/lib/logic.ts` library, shared across all components.
+  - **Policy-Driven UI**: Introduced `FrontendTargetIR` with resolved policies for styling (e.g., custom primary colors) and framework configuration, enabling consistent UI decisions across the generated project.
+  - **Dependency Tracking**: Implemented automatic dependency extraction for logical expressions, allowing generated `useEffect` hooks to trigger only when necessary (optimized rerenders).
+- **Electron Target (Multi-frontend)**: Added Electron target lowering + emitter (`electron-shell`) that generates `main.ts`, `preload.ts`, `ipc-handlers.ts`, `package.json`, `tsconfig.json`, and helper scripts. IPC whitelist + custom handler stubs come from DSL policies (`policies.electron.ipc`), and the emitter avoids double-registering built-in handlers. FrontendIR is shared between Web/PWA and Electron via policy-driven lowering.
+- **Electrobun Extension (sample)**: Optional extension emits Electrobun bundle (config, IR summary, page/component stubs, barrel, main stub, package.json with Bun+electrobun scripts). Upstream Electrobun CLI may have platform limitations (see electrobun issue #10).
+- **Target lowering rename**: Target transforms standardized to `lowering/targets/to-*.ts` (to-backend, to-frontend, to-electron, etc.) for clarity.
+- **Electron hardening & lifecycle**: Added security defaults (window.open/will-navigate guards, CSP header, eval/Function disabled), reliability (single instance, window state persist/restore), logging, crash reporting slot, auto-update wiring with renderer status events and retry-on-fail, and session-aware IPC cleanup. Auto-update policies support provider/url/channel, prerelease opt-in, headers, and retry tuning.
+
+### Pending / Parity Gaps vs Form.io (Future PRs)
+- Components: survey, address/geo, select grid/resource grid, nested form/wizard/steps, edit grid/repeater, file upload storage adapter.
+- Validation/Logic: stronger JSONLogic coverage (full operator set), i18n-friendly messages, richer unique/async validation.
+- UX: dedicated i18n, richer per-field skeletons, configurable async select adapters, select grid.
+- Actions: custom action handlers beyond submit (custom buttons/hooks).
+- Styling/Templates: custom render templates per component/theme slots.
+#### Developer Experience
+- **Unified DSL**: Updated `app.dsl.ts` and introduced `fullstack.dsl.ts` examples.
+- **Examples Organization**: `generate-examples.sh` script to manage multiple example outputs in dedicated folders.
+- **Runtime Typing**: Improved TypeScript types for DSL runtime (`frontend-runtime.ts`).

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2025 irgen
+
+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,161 @@
+# irgen (Robust Fullstack Generator)
+
+[![CI](https://github.com/agusmade/irgen/actions/workflows/ci.yml/badge.svg?branch=main)](https://github.com/agusmade/irgen/actions/workflows/ci.yml)
+
+> **Compiler-style code generation via Intermediate Representation.**
+
+irgen is a compiler-style code generation toolchain built around Intermediate Representation (IR). You describe your system in terms of **domain and policy**, and irgen performs IR transformations to generate backend, frontend, desktop, mobile, and documentation targets for you.
+
+irgen is designed for developers who want architectural clarity without maintaining endless glue code. Unlike typical scaffolders, **source code is owned by the tool**, while **user code is preserved** via the [Generation Gap Pattern](https://martinfowler.com/dslwip/GenerationGap.html).
+
+### What irgen is NOT
+irgen focuses on **architecture and determinism**, not convenience shortcuts. irgen is **not**:
+- A framework or a library
+- A simple scaffolding tool
+- A template generator
+- An AI-driven code writer
+
+## Key Features
+
+### Backend (Node.js/TypeScript)
+- **Generation Gap Architecture**: Separates generated base classes from user implementation. Regenerate safely without losing manual changes.
+- **Repository Pattern**: Auto-generated repositories with Dependency Injection (DI) support.
+- **Prisma Integration**: Database schema and client management out-of-the-box.
+- **Extensibility Hooks**: `beforeCreate`, `afterCreate`, etc., in services for custom business logic.
+- **Automated Testing**: Auto-generated `vitest` unit tests for services.
+
+### Frontend (React/Vite)
+- **General-Purpose Webapp Generator**: Move beyond "dashboard-only" UIs. Generate any web application by defining operations and data sources.
+- **Headless Client Runtime**: Decoupled `lib/runtime.ts` and React hooks (`useOperation`, `useResource`) manage interaction with any backend (REST, GraphQL, etc.).
+- **Operation-Oriented Architecture**: Actions (Operations) are the fundamental units of the client, allowing for complex command-oriented UIs.
+- **DataSource Abstraction**: Connect to multiple backends with pluggable `AuthStrategy`, `EnvelopeAdapter`, and `PaginationAdapter`.
+- **Global Dark Mode**: Built-in persistence (`localStorage`) and toggle in a sleek, glassmorphism Navbar.
+- **Rich UI Components**:
+  - **Forms**: 30+ field types including slider, currency, tags, file upload, and signature.
+  - **Table**: First-class table component with direct operation/resource binding and pagination.
+  - **Marketing**: Responsive Hero, Features, Testimonials, FAQ, Logos, CTA, Stats, and Timeline sections.
+  - **Dev Tools**: Native **Syntax Highlighter** (`CodeBlock`) with automatic dependency management.
+- **Multi-app Support**: Set `basePath` to deploy multiple apps (e.g., `/admin`, `/docs`) under a single project or domain.
+- **Form Logic & UX**: JSONLogic predicates, dependency-tracked hooks, async select with debounce/pagination/search.
+- **Submission Pipeline**: Lifecycle hooks, confirm dialogs, response handling, and draft persistence.
+
+### Static Site (HTML-first)
+- **HTML-only output**: emits final HTML (no React hydration), JS is strictly progressive enhancement.
+- **Policy-driven output**: routing, SEO/meta, assets, theming, and enhancements are controlled via `staticSite` policy.
+- **Optional enhancements**: sidebar toggle, copy code, theme toggle, TOC scroll spy, and client-side search.
+- **Build-time highlighting**: Shiki for pre-highlight, optional Prism runtime for client mode.
+
+## Quick Start
+
+### 1. Install Dependencies
+```bash
+npm install
+```
+
+### Security note
+If you enable JWT auth in generated backends, replace the default placeholder secret (`CHANGE_ME_SUPER_SECRET_MIN_16_CHARS`) with a real value.
+
+### 2. Run Examples
+We provide a script to generate all example projects into `generated/` folders:
+
+```bash
+./scripts/generate-examples.sh
+```
+
+### 3. Explore Outputs
+- **Backend Only**: `generated/backend-only/`
+- **Frontend Only**: `generated/frontend-only/`
+- **Rich Frontend**: `generated/form-io/` (Run `npm install && npm run dev` inside to see the UI)
+- **Multi-page Website**: `generated/irgen-web/` (from `examples/irgen-web.dsl.ts`)
+- **Fullstack**: `generated/fullstack/` (backend and frontend are generated independently)
+- **Docs (PWA-ready)**: `generated/docs/` (from `examples/docs.dsl.ts`)
+- **Static Docs (HTML-first)**: `generated/static-docs/` (from `examples/docs.dsl.ts` with `--targets=static-site`)
+- **Static Site (No Enhance)**: `generated/static-no-enhance/`
+- **Static Site (With Enhance)**: `generated/static-with-enhance/`
+
+## Manual Generation
+You can generate artifacts from a specific DSL file using the CLI:
+
+```bash
+# General Backend
+npx irgen examples/app.dsl.ts generated/my-app --mode=backend
+
+# Frontend (FormIO style)
+npx irgen examples/form-io.dsl.ts generated/my-frontend --mode=frontend
+
+# Backend + Frontend (separate targets)
+npx irgen examples/app.dsl.ts --targets=backend,frontend --outDir=generated/fullstack
+# -> backend in generated/fullstack/backend, frontend in generated/fullstack/frontend
+
+# Static-site (HTML-first)
+npx irgen examples/docs.dsl.ts --targets=static-site --outDir=generated/static-docs
+```
+
+### Optional: enable PWA for frontend outputs
+- Opt-in via CLI policies:  
+`npx irgen examples/fullstack.dsl.ts generated/fullstack --targets=backend,frontend`
+- This writes `manifest.webmanifest`, `icons/icon.svg`, and `pwa-sw.js`, then registers the service worker in the generated frontend entry. Defaults stay off unless you set `pwa.enabled=true` (recommended via the options argument to `frontend(...)` in your DSL; you can still override with `--policies='{"frontend":{"pwa":{"enabled":true,"name":"irgen Docs","shortName":"IRDocs"}}}'` if you prefer CLI flags).
+- Frontend outputs now include a minimal Vite setup. After generation run `npm install` then `npm run dev` inside the frontend folder (e.g. `generated/fullstack/frontend`) to serve the app.
+- Backend and frontend packages are decoupled: backend outputs stay backend-only; frontend outputs ship their own `package.json` with React/router/Tailwind toolchain.
+
+## JS Module API & Extensions
+- Import the DSL helpers directly:
+  ```ts
+  import { app, frontend } from "irgen";
+
+  app("My Backend", { policies: { backend: { generateId: "uuid_v4" } } }, (be) => { /* ... */ });
+  frontend("My Frontend", { pwa: { enabled: true } }, (fe) => { /* ... */ });
+  ```
+- Programmatic generation with extensions:
+  ```ts
+  import { Codegen } from "irgen";
+  import myExtension from "./my-extension.js";
+
+  const codegen = new Codegen({ extensions: [myExtension] });
+  await codegen.generate({ entries: ["./myapp.ts"], targets: ["backend", "frontend"], outDir: "generated" });
+  ```
+- Extension shape: export a function `(ctx, options?) => void|Promise<void>` and use the provided `ctx` to register mappers/transforms/emitters/target mappings:
+  ```ts
+  // my-extension.ts
+  export default (ctx) => {
+    ctx.registerTargetEmitter("my-target", "my-emitter");
+    ctx.registerMapper("my-target", (decl) => {/* ... */}, { force: true });
+  };
+  ```
+- CLI can load extensions too: `npx irgen ./myapp.ts --targets=backend,frontend --ext=./my-extension.ts`
+- Electron target: IPC whitelist and handler stubs can be declared in the DSL via `policies.electron.ipc` (whitelist + `handlers`), and the emitter generates `ipc-handlers.ts` wired to `main.ts`, `preload.ts`, and `load-file.js`. Electron shell includes security hardening (contextIsolation/nodeIntegration off, navigation/CSP guards), session restore (window state persisted to userData), crash reporting slot, auto-update wiring with renderer status events (`auto-update-status`), and optional retry on failure.
+- Extension namespacing & order: built-ins register first; extensions load in order. Use `ctx.namespace("myExt")` to prefix registrations (e.g., `myExt:frontend`) to avoid collisions. See `docs/EXTENSIONS.md` for details.
+
+Notes:
+- Published CLI (`npx irgen`) can load `.dsl.ts` (and its `.ts` imports) directly using the built-in tsx loader.
+- For local development inside this repo, you can still run `npx tsx src/cli.ts ...` if preferred.
+
+## Release
+Releases are published to npm automatically via GitHub Actions when a version tag is pushed.
+
+```bash
+npm version <patch|minor|major>
+git push origin main --follow-tags
+```
+
+## Contributing
+Please read [CONTRIBUTING.md](CONTRIBUTING.md) before opening a PR.
+
+## Security
+If you believe you have found a security vulnerability, please follow [SECURITY.md](SECURITY.md).
+
+## Architecture
+See [docs/ARCHITECTURE.md](docs/ARCHITECTURE.md) for details on:
+- Generation Gap Pattern
+- Port & Adapters (Hexagonal)
+- Frontend Runtime & IR
+- Frontend SSG plan: [docs/FRONTEND-SSG-PLAN.md](docs/FRONTEND-SSG-PLAN.md)
+
+## Roadmap
+- [x] Separation of Concerns (Generated vs User space)
+- [x] Dependency Injection & Repositories
+- [x] Prisma ORM Adapter
+- [x] Extensibility Hooks
+- [x] Automated Testing
+- [x] Rich Frontend Components & Routing
+- [x] Frontend SSG/Hybrid (Vite prerender)

package/dist/cli.d.ts

@@ -0,0 +1,3 @@
+#!/usr/bin/env node
+export {};
+//# sourceMappingURL=cli.d.ts.map

package/dist/cli.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"cli.d.ts","sourceRoot":"","sources":["../src/cli.ts"],"names":[],"mappings":""}

package/dist/cli.js

@@ -0,0 +1,312 @@
+#!/usr/bin/env node
+import path from "node:path";
+import { pathToFileURL } from "node:url";
+import { aggregateDecls } from "./dsl/aggregator.js";
+import { registerBuiltins, runMapper } from "./mappers/index.js";
+// Guard: require a modern Node (tsx loader relies on module.register)
+const NODE_MAJOR = Number(process.versions.node.split(".")[0]);
+if (Number.isFinite(NODE_MAJOR) && NODE_MAJOR < 18) {
+    console.error(`irgen requires Node.js >=18 (detected ${process.versions.node}). Please switch to a newer Node before running the CLI.`);
+    process.exit(1);
+}
+async function main() {
+    if (process.argv.includes("--help") || process.argv.includes("-h")) {
+        console.log(`
+irgen — Policy-Driven Multi-Target Code Generation Toolchain
+
+Usage:
+  irgen <dsl-file> [outDir] [options]
+
+Options:
+  --mode=<mode>        Target mode: backend, frontend, electron, static-site, combined (default: backend)
+  --targets=<list>     Comma-separated list of targets to emit (overrides --mode)
+  --outDir=<path>      Directory to write generated code (default: ./generated)
+  --ext=<path>         Path to extension module(s)
+  --emitters           List all registered emitters
+  --emitter=<name>     Force run a specific emitter
+  --emitter-map=<json> Override emitter mapping for targets (e.g. '{"backend":"my-custom-node"}')
+  --policies=<json>    Override policies from CLI
+  --version, -v        Show version information
+  --help, -h           Show this help message
+
+Debugging / Inspection:
+  --inspect-decl       Print the aggregated Declaration IR (input)
+  --inspect-domain     Print the Domain IR (semantic model)
+  --inspect-ir         Print the final Target IR (emitter contract)
+
+Examples:
+  npx irgen examples/app.dsl.ts --mode=combined
+  npx irgen examples/frontend.dsl.ts --targets=frontend,electron --outDir=my-app
+    `);
+        process.exit(0);
+    }
+    if (process.argv.includes("--version") || process.argv.includes("-v")) {
+        console.log("irgen 0.1.0");
+        process.exit(0);
+    }
+    try {
+        const { register } = await import("tsx/esm/api");
+        register();
+    }
+    catch (err) {
+        console.warn("tsx loader unavailable; falling back to manual TS transpile where supported.", err instanceof Error ? err.message : err);
+    }
+    const modeFlag = process.argv.find(a => a.startsWith("--mode=")) ?? "--mode=backend";
+    const mode = modeFlag.split("=")[1];
+    // Additional flags: --emitters (list emitters), --emitter=<name> (run one emitter)
+    const showEmitters = process.argv.includes("--emitters");
+    const emitterFlag = process.argv.find(a => a.startsWith("--emitter=")) ?? null;
+    const emitterName = emitterFlag ? emitterFlag.split("=")[1] : null;
+    // parse positional args: first DSL entry and optional outDir
+    const rawArgs = process.argv.slice(2);
+    const extFlags = rawArgs.filter(a => a.startsWith("--ext="));
+    const extModules = extFlags.flatMap(f => f.replace("--ext=", "").split(",")).filter(Boolean);
+    const outDirFlag = process.argv.find(a => a.startsWith("--outDir=")) ?? null;
+    const entries = rawArgs.filter(a => a.endsWith(".dsl.ts"));
+    const entry = entries[0];
+    const entryIndex = entry ? rawArgs.indexOf(entry) : -1;
+    const maybeOut = entryIndex >= 0 ? rawArgs[entryIndex + 1] : undefined;
+    // Logic: Explicit flag > Positional arg (if valid) > Default
+    const outDir = outDirFlag
+        ? outDirFlag.split("=")[1]
+        : (maybeOut && !maybeOut.startsWith("--") ? maybeOut : "generated");
+    // helper: import all emit modules so they can register themselves
+    async function importAllEmitters() {
+        try {
+            const fs = await import("node:fs/promises");
+            async function walk(dir) {
+                const entries = await fs.readdir(dir, { withFileTypes: true });
+                for (const ent of entries) {
+                    if (ent.isDirectory()) {
+                        await walk(new URL(`./${ent.name}/`, dir));
+                    }
+                    else if (ent.name.endsWith(".js") || ent.name.endsWith(".ts")) {
+                        try {
+                            await import(new URL(`./${ent.name}`, dir).href);
+                        }
+                        catch (e) {
+                            // ignore import errors for optional files
+                        }
+                    }
+                }
+            }
+            await walk(new URL("./emit/", import.meta.url));
+        }
+        catch (e) {
+            // ignore errors when emit directory is missing
+        }
+    }
+    async function importEmitterModule(relPath) {
+        const asUrl = (p) => new URL(p, import.meta.url).href;
+        try {
+            await import(asUrl(relPath));
+            return { ok: true, err: null };
+        }
+        catch (err) {
+            return { ok: false, err };
+        }
+    }
+    async function ensureEmitterRegistration(targets) {
+        if (!targets.includes("frontend"))
+            return;
+        const { emitterEngine } = await import("./emit/engine.js");
+        if (emitterEngine.getEmitter("frontend-tsmorph"))
+            return;
+        let lastErr = null;
+        let lastAttempt = null;
+        try {
+            const res = await importEmitterModule("./emit/frontend/frontend-react.js");
+            lastAttempt = "./emit/frontend/frontend-react.js";
+            if (!res.ok) {
+                throw res.err ?? new Error("frontend-react.js import failed");
+            }
+        }
+        catch (err) {
+            lastErr = err;
+            try {
+                const res = await importEmitterModule("./emit/frontend/frontend-react.ts");
+                lastAttempt = "./emit/frontend/frontend-react.ts";
+                if (!res.ok) {
+                    throw res.err ?? new Error("frontend-react.ts import failed");
+                }
+            }
+            catch (err2) {
+                lastErr = err2;
+            }
+        }
+        if (!emitterEngine.getEmitter("frontend-tsmorph")) {
+            const msg = lastErr instanceof Error ? lastErr.message : String(lastErr ?? "unknown error");
+            const attempt = lastAttempt ? ` (${lastAttempt})` : "";
+            throw new Error(`failed to register frontend emitter${attempt}: ${msg}`);
+        }
+    }
+    const targetsFlag = process.argv.find(a => a.startsWith("--targets=")) ?? null;
+    const targetsFromFlag = targetsFlag ? targetsFlag.split("=")[1].split(",").map(t => t.trim()).filter(Boolean) : null;
+    const normalizeModeToTargets = (m) => {
+        if (targetsFromFlag && targetsFromFlag.length > 0)
+            return targetsFromFlag;
+        if (m === "combined")
+            return ["backend", "frontend"];
+        if (m === "frontend" || m === "backend" || m === "electron" || m === "static-site")
+            return [m];
+        if (m === "electrobun")
+            return ["electrobun"];
+        return ["backend"];
+    };
+    const targets = normalizeModeToTargets(mode);
+    if (showEmitters) {
+        await importAllEmitters();
+        await ensureEmitterRegistration(targets);
+        const { emitterEngine } = await import("./emit/engine.js");
+        console.log("Registered emitters:", emitterEngine.listEmitters().join(", "));
+        process.exit(0);
+    }
+    const defaultEntry = entry
+        ?? ((targets.includes("frontend") || targets.includes("electron") || targets.includes("electrobun") || targets.includes("static-site"))
+            ? "examples/frontend.dsl.ts"
+            : "examples/app.dsl.ts");
+    // normalise entries array (fallback to example DSL when not provided)
+    const entriesArr = entries.length ? entries : [defaultEntry];
+    const inspectIR = process.argv.includes("--inspect-ir");
+    const inspectDomain = process.argv.includes("--inspect-domain");
+    const inspectDecl = process.argv.includes("--inspect-decl");
+    const policiesFlag = process.argv.find(a => a.startsWith("--policies=")) ?? null;
+    const policiesFromCli = policiesFlag ? JSON.parse(policiesFlag.split("=")[1]) : undefined;
+    const emitterMapFlag = process.argv.find(a => a.startsWith("--emitter-map=")) ?? null;
+    const emitterMap = emitterMapFlag ? JSON.parse(emitterMapFlag.split("=")[1]) : undefined;
+    // Aggregate all entries into DeclUnified (validation/normalization inside)
+    const prefer = targets.some(t => t === "frontend" || t === "electron" || t === "electrobun" || t === "static-site") ? "frontend" : "backend";
+    const unified = await aggregateDecls(entriesArr, { prefer });
+    if (inspectDecl)
+        console.log("INSPECT-DECL:", JSON.stringify(unified, null, 2));
+    // ensure built-in mappers are available before extensions register/compose
+    registerBuiltins();
+    async function loadExtensions() {
+        if (!extModules.length)
+            return;
+        const { createExtensionContext } = await import("./extensions/context.js");
+        const ctx = createExtensionContext();
+        for (const modPath of extModules) {
+            const abs = path.isAbsolute(modPath) ? modPath : path.resolve(process.cwd(), modPath);
+            const modUrl = pathToFileURL(abs).href;
+            const imported = await import(modUrl);
+            const fn = (imported.default ?? imported.extension ?? imported);
+            if (typeof fn === "function") {
+                fn(ctx, imported.options ?? undefined);
+            }
+            else {
+                console.warn(`extension module ${modPath} did not export a function`);
+            }
+        }
+    }
+    await loadExtensions();
+    const bundlePolicies = unified?.meta?.policies;
+    const pickPolicy = (src, target) => {
+        if (!src)
+            return undefined;
+        if (src[target])
+            return src[target];
+        // Also check for kebab-case and camelCase variations
+        const camelVariant = target.replace(/-([a-z])/g, (_, c) => c.toUpperCase());
+        const targetVariations = [
+            target,
+            target.replace(/-/g, ""),
+            target.replace(/([A-Z])/g, "-$1").toLowerCase(),
+            camelVariant,
+        ];
+        for (const variant of targetVariations) {
+            if (src[variant])
+                return src[variant];
+        }
+        const keys = Object.keys(src);
+        const looksNamespaced = keys.some(k => ["backend", "frontend", "electron", "cli", "static-site", "staticSite"].includes(k));
+        return looksNamespaced ? undefined : src;
+    };
+    const policyForTarget = (target) => {
+        const fromDsl = pickPolicy(bundlePolicies, target);
+        const fromCli = pickPolicy(policiesFromCli, target);
+        if (fromDsl && fromCli)
+            return { ...fromDsl, ...fromCli };
+        return fromCli ?? fromDsl;
+    };
+    // ensure emitters and transforms are registered
+    await importAllEmitters();
+    await ensureEmitterRegistration(targets);
+    // ensure target lowering transforms are registered when available
+    if (targets.includes("backend"))
+        await import("./lowering/targets/to-backend.js");
+    if (targets.includes("frontend"))
+        await import("./lowering/targets/to-frontend.js");
+    if (targets.includes("electron"))
+        await import("./lowering/targets/to-electron.js");
+    if (targets.includes("static-site"))
+        await import("./lowering/targets/to-static-site.js");
+    const { engine } = await import("./lowering/engine.js");
+    const { emitterEngine } = await import("./emit/engine.js");
+    const { getEmitterForTarget } = await import("./emit/registry.js");
+    const singleTargetOutDir = (target) => {
+        const multipleTargets = targets.length > 1;
+        return multipleTargets ? path.resolve(process.cwd(), outDir, target) : path.resolve(process.cwd(), outDir);
+    };
+    if (emitterName) {
+        if (!emitterEngine.getEmitter(emitterName)) {
+            throw new Error(`emitter not registered: ${emitterName}`);
+        }
+        // infer mode if user didn't pass --mode
+        let chosenMode = mode;
+        if (!process.argv.find(a => a.startsWith("--mode="))) {
+            if (emitterName.includes("backend"))
+                chosenMode = "backend";
+            else if (emitterName.includes("frontend"))
+                chosenMode = "frontend";
+        }
+        const domainIr = await runMapper(chosenMode, unified, policyForTarget(chosenMode));
+        if (inspectDomain)
+            console.log(`INSPECT-DOMAIN (${chosenMode}):`, JSON.stringify(domainIr, null, 2));
+        const transformName = `${chosenMode}-target`;
+        const targetIr = engine.getTransform(transformName)
+            ? await engine.runTransform(transformName, domainIr, policyForTarget(chosenMode))
+            : domainIr;
+        if (inspectIR)
+            console.log(`INSPECT-IR (${chosenMode}):`, JSON.stringify(targetIr, null, 2));
+        await emitterEngine.runEmitter(emitterName, targetIr, singleTargetOutDir(chosenMode));
+        console.log(`Ran emitter ${emitterName} (${chosenMode}) -> ${outDir}`);
+        process.exit(0);
+    }
+    for (const target of targets) {
+        let ir;
+        try {
+            const domainIr = await runMapper(target, unified, policyForTarget(target));
+            if (inspectDomain)
+                console.log(`INSPECT-DOMAIN (${target}):`, JSON.stringify(domainIr, null, 2));
+            const transformName = `${target}-target`;
+            ir = engine.getTransform(transformName)
+                ? await engine.runTransform(transformName, domainIr, policyForTarget(target))
+                : domainIr;
+        }
+        catch (err) {
+            console.error(`failed to map target ${target}:`, err);
+            continue;
+        }
+        if (inspectIR)
+            console.log(`INSPECT-IR (${target}):`, JSON.stringify(ir, null, 2));
+        const chosenEmitter = (emitterMap?.[target]) ??
+            getEmitterForTarget(target) ??
+            (target === "backend" ? "backend-tsmorph" : target === "frontend" ? "frontend-tsmorph" : target === "electron" ? "electron-shell" : target === "static-site" ? "static-site-html" : null);
+        if (!chosenEmitter) {
+            console.warn(`no emitter mapping for target ${target}, skipping emit`);
+            continue;
+        }
+        await emitterEngine.runEmitter(chosenEmitter, ir, singleTargetOutDir(target));
+    }
+    console.log("OK");
+    console.log("MODE:", process.argv.find(a => a.startsWith("--mode=")) ? mode : "(auto)");
+    console.log("TARGETS:", targets.join(", "));
+    console.log("DSL :", entriesArr.join(", "));
+    console.log("OUT :", outDir);
+}
+main().catch((err) => {
+    console.error(err);
+    process.exit(1);
+});
+//# sourceMappingURL=cli.js.map