irgen 0.3.0 → 0.3.2

package/CHANGELOG.md

@@ -2,6 +2,31 @@
 
 All notable changes to the `irgen` project will be documented in this file.
 
+## [0.3.2] - 2026-02-04
+
+### Enhancements
+- **CLI Execution Order**: Refactored the core entry point to ensure TypeScript support (`tsx`) and extensions (`--ext`) are fully loaded before subcommands (`init`, `studio`, `check`) are executed.
+- **Detailed CLI Help**: Added specialized help messages for `init`, `studio`, and `check` commands, providing better guidance on parameters and extension usage.
+- **Resilient Studio Dashboard**: Updated the Studio UI to be more robust when visualizing complex Hybrid applications (Backend + Frontend) and added better error handling for malformed IR.
+
+### Bug Fixes
+- **Studio Data Loading**: Fixed an issue where the Studio dashboard would appear empty when using extension-specific DSLs due to late extension loading.
+
+## [0.3.1] - 2026-02-03
+
+### New Features
+- **🐘 PHP Hybrid App Platform**: Major enhancement to the `php-shared-hosting` extension, transforming it into a full-stack platform for shared hosting.
+    - **Multi-App Support**: Host any number of React SPAs (Admin, Portal, User App) on a single shared hosting account with automatic dynamic routing.
+    - **MySQL/REST Engine**: DSL `entity()` declarations automatically generate secure PHP REST controllers using a shared PDO-based storage engine.
+    - **Aesthetic Blogging**: Premium flat-file blogging system with refined typography, dark mode, RSS, and Sitemap.
+- **Extension CLI Contributions**: Extensions can now contribute custom logic to core CLI commands.
+- **Pluggable Validators**: Use `ctx.registerValidator` to add custom semantic checks to `irgen check`.
+- **Pluggable Templates**: Use `ctx.registerTemplate` for project starters in `irgen init`.
+
+### Enhancements
+- **Improved Extension Loading**: Unified extension loader with robust path resolution for local files and npm packages.
+- **Improved Multi-DSL Aggragation**: Core now supports flattening and merging applications from multiple DSL files into a single IR bundle.
+
 ## [0.3.0] - 2026-02-01
 
 ### New Features

package/README.md

@@ -92,6 +92,9 @@ npx irgen examples/app.dsl.ts --targets=backend,frontend --outDir=generated/full
 # Static-site (HTML-first)
 npx irgen examples/docs.dsl.ts --targets=static-site --outDir=generated/static-docs
 
+> [!TIP]
+> **Working with multiple DSL files?** Instead of passing multiple files to the CLI, use a **single entry point** and `import` your other DSL files. This ensures your project structure remains clean and prevents CLI ambiguity.
+
 ## Specialized Commands
 
 ### Project Scaffolding

package/dist/cli/check.js

@@ -1,6 +1,22 @@
 import { aggregateDecls } from "../dsl/aggregator.js";
 import { validateSemantics } from "../dsl/validator.js";
 export async function runCheck(args) {
+    if (args.includes("--help") || args.includes("-h")) {
+        console.log(`
+irgen check — Semantic validation for irgen DSL files
+
+Usage:
+  irgen check <dsl-file>... [options]
+
+Options:
+  --ext=<path>         Load extensions (for extension-specific validation)
+  --help, -h           Show this help message
+
+Example:
+  npx irgen check app.dsl.ts ui.dsl.ts --ext=irgen-ext-php-shared-hosting
+        `);
+        return;
+    }
     const dslFiles = args.filter(a => a.endsWith(".dsl.ts"));
     if (dslFiles.length === 0) {
         console.error("Usage: irgen check <dsl-file>...");

package/dist/cli/extensions.d.ts

@@ -0,0 +1 @@
+export declare function loadExtensions(extModules: string[]): Promise<void>;

package/dist/cli/extensions.js

@@ -0,0 +1,72 @@
+import path from "node:path";
+import fs from "node:fs";
+import { pathToFileURL } from "node:url";
+import { createRequire } from "node:module";
+import { createExtensionContext } from "../extensions/context.js";
+const require = createRequire(import.meta.url);
+export async function loadExtensions(extModules) {
+    if (!extModules.length)
+        return;
+    const ctx = createExtensionContext();
+    const pickExtensionFn = (mod) => {
+        const candidate = (mod?.default ?? mod?.extension ?? mod);
+        if (typeof candidate === "function")
+            return candidate;
+        if (candidate && typeof candidate === "object") {
+            if (typeof candidate.default === "function")
+                return candidate.default;
+            if (typeof candidate.extension === "function")
+                return candidate.extension;
+        }
+        return null;
+    };
+    const resolveExtensionModule = (spec) => {
+        const isPathLike = spec.startsWith(".") || spec.startsWith("/") || /^[A-Za-z]:[\\/]/.test(spec) || fs.existsSync(path.resolve(process.cwd(), spec));
+        if (isPathLike) {
+            let abs = path.isAbsolute(spec) ? spec : path.resolve(process.cwd(), spec);
+            if (!fs.existsSync(abs)) {
+                // Try with common extensions if not found
+                let found = false;
+                for (const ext of [".ts", ".js", ".mjs"]) {
+                    if (fs.existsSync(abs + ext)) {
+                        abs = abs + ext;
+                        found = true;
+                        break;
+                    }
+                }
+                if (!found)
+                    throw new Error(`extension module not found: ${spec}`);
+            }
+            return pathToFileURL(abs).href;
+        }
+        try {
+            const resolved = require.resolve(spec, { paths: [process.cwd()] });
+            return pathToFileURL(resolved).href;
+        }
+        catch (e) {
+            // Fallback for namespaced packages or modules that might not be in node_modules yet
+            return spec;
+        }
+    };
+    for (const modPath of extModules) {
+        try {
+            const modUrl = resolveExtensionModule(modPath);
+            const imported = await import(modUrl);
+            const fn = pickExtensionFn(imported);
+            if (typeof fn === "function") {
+                const metadata = imported.extensionMetadata || imported.metadata || {};
+                const name = metadata.name || path.basename(modPath, path.extname(modPath)).replace(/^irgen-ext-/, "");
+                const version = metadata.version ? ` v${metadata.version}` : "";
+                ctx.logger.info(`Loading extension: ${name}${version}`);
+                const namespacedCtx = ctx.namespace(name);
+                await fn(namespacedCtx, imported.options ?? undefined);
+            }
+            else {
+                console.warn(`extension module ${modPath} did not export a function`);
+            }
+        }
+        catch (err) {
+            console.error(`Failed to load extension "${modPath}": ${err.message}`);
+        }
+    }
+}

package/dist/cli/init.js

@@ -2,10 +2,36 @@ import prompts from "prompts";
 import fs from "node:fs";
 import path from "node:path";
 export async function runInit(args) {
-    const defaultName = args[0] || "my-irgen-app";
+    if (args.includes("--help") || args.includes("-h")) {
+        const { templateRegistry } = await import("./template-registry.js");
+        const extTemplates = templateRegistry.getTemplates();
+        console.log(`
+irgen init — Scaffold a new irgen project
+
+Usage:
+  irgen init <projectName> [options]
+
+Options:
+  --ext=<path>         Load extensions (provides extra templates)
+  --help, -h           Show this help message
+
+Available Templates:
+  - fullstack          Standard Backend + Frontend (React)
+  - backend            Node.js/Prisma backend only
+  - frontend           React/Vite frontend only
+${extTemplates.map(t => `  - ${t.id.padEnd(18)} ${t.title}`).join("\n")}
+
+Example:
+  npx irgen init my-blog --ext=irgen-ext-php-shared-hosting --template=php-blog
+        `);
+        return;
+    }
+    const { templateRegistry } = await import("./template-registry.js");
+    const extTemplates = templateRegistry.getTemplates();
+    const defaultName = args.find(a => !a.startsWith("-")) || "my-irgen-app";
     const response = await prompts([
         {
-            type: args[0] ? null : "text",
+            type: (args.find(a => !a.startsWith("-"))) ? null : "text",
             name: "projectName",
             message: "Project name:",
             initial: defaultName
@@ -18,6 +44,7 @@ export async function runInit(args) {
                 { title: "Fullstack (Backend + Frontend)", value: "fullstack" },
                 { title: "Backend Only", value: "backend" },
                 { title: "Frontend Only", value: "frontend" },
+                ...extTemplates.map(t => ({ title: t.title, value: t.id }))
             ],
             initial: 0
         }
@@ -29,6 +56,15 @@ export async function runInit(args) {
         console.error(`Error: Directory ${projectName} already exists.`);
         process.exit(1);
     }
+    // Handle extension templates
+    const extTemplate = templateRegistry.getTemplate(template);
+    if (extTemplate) {
+        console.log(`\nScaffolding project in ${projectDir} using template ${extTemplate.title}...`);
+        fs.mkdirSync(projectDir, { recursive: true });
+        await extTemplate.generate(projectDir, response);
+        console.log("\nDone!");
+        return;
+    }
     console.log(`\nScaffolding project in ${projectDir}...`);
     fs.mkdirSync(projectDir, { recursive: true });
     // 1. package.json

package/dist/cli/studio.js

@@ -4,6 +4,25 @@ import { aggregateDecls } from "../dsl/aggregator.js";
 import path from "node:path";
 import fs from "node:fs";
 export async function runStudio(args) {
+    if (args.includes("--help") || args.includes("-h")) {
+        console.log(`
+irgen studio — Interactive DSL Dashboard
+
+Usage:
+  irgen studio <dsl-file>... [options]
+
+Options:
+  --ext=<path>         Load extensions (to visualize custom mappers/emitters)
+  --help, -h           Show this help message
+
+The Studio provides a real-time visual representation of your system's
+entities, pages, and components as defined in your DSL.
+
+Example:
+  npx irgen studio app.dsl.ts ui.dsl.ts --ext=irgen-ext-php-shared-hosting
+        `);
+        return;
+    }
     const dslFiles = args.filter(a => a.endsWith(".dsl.ts"));
     if (dslFiles.length === 0) {
         console.error("Usage: irgen studio <dsl-file>...");
@@ -40,7 +59,6 @@ export async function runStudio(args) {
         res.json(currentIR);
     });
     // Static UI
-    // For now, let's embed a simple but beautiful HTML
     app.get("/", (req, res) => {
         res.send(getStudioHtml());
     });
@@ -278,14 +296,17 @@ function getStudioHtml() {
             document.getElementById('header-content').innerHTML = '<h2>Project Overview</h2><p>Summary of discovered resources</p>';
             let totalEntities = 0;
             let totalPages = 0;
-            ir.apps.forEach(a => { totalEntities += (a.entities?.length || 0); totalPages += (a.pages?.length || 0); });
+            ir.apps.forEach(a => { 
+                if (a.entities) totalEntities += a.entities.length;
+                if (a.pages) totalPages += a.pages.length;
+            });
 
             const content = document.getElementById('content');
             content.innerHTML = \`
                 <div class="stats-row">
                     <div class="stat-card">
                         <div class="stat-value">\${ir.apps.length}</div>
-                        <div class="stat-label">Applications</div>
+                        <div class="stat-label">Applications / Modules</div>
                     </div>
                     <div class="stat-card">
                         <div class="stat-value">\${totalEntities}</div>
@@ -297,14 +318,22 @@ function getStudioHtml() {
                     </div>
                 </div>
                 <div class="card">
-                    <h3>Metadata</h3>
+                    <h3>Metadata & Configuration</h3>
                     <table class="mono">
-                        \${Object.entries(ir.apps[0]?.meta || {}).map(([k,v]) => \`
+                        \${Object.entries(ir.meta || {}).map(([k,v]) => \`
                             <tr>
-                                <td style="color: var(--accent)">\${k}</td>
-                                <td>\${JSON.stringify(v)}</td>
+                                <td style="color: var(--accent); width: 200px">\${k}</td>
+                                <td><pre style="margin:0; white-space: pre-wrap">\${JSON.stringify(v, null, 2)}</pre></td>
                             </tr>
                         \`).join('')}
+                        \${ir.apps.map(app => 
+                            Object.entries(app.meta || {}).map(([k,v]) => \`
+                                <tr>
+                                    <td style="color: var(--text-dim)">[\${app.name}] \${k}</td>
+                                    <td><pre style="margin:0; white-space: pre-wrap">\${JSON.stringify(v, null, 2)}</pre></td>
+                                </tr>
+                            \`).join('')
+                        ).join('')}
                     </table>
                 </div>
             \`;
@@ -352,7 +381,7 @@ function getStudioHtml() {
                                     <strong>\${comp.name}</strong>
                                     \${comp.entityRef ? '<span class="badge">Bound</span>' : ''}
                                 </div>
-                                \${comp.entityRef ? \`<div class="stat-label">Entity: \${comp.entityRef}</div>\` : ''}
+                                \${comp.entityRef ? \\\`<div class="stat-label">Entity: \\\${comp.entityRef}</div>\\\` : ''}
                             </div>
                         \`).join('')}
                     </div>

package/dist/cli/template-registry.d.ts

@@ -0,0 +1,15 @@
+export type TemplateDefinition = {
+    id: string;
+    title: string;
+    description?: string;
+    generate: (projectDir: string, options: any) => Promise<void> | void;
+};
+declare class TemplateRegistry {
+    private templates;
+    register(template: TemplateDefinition): void;
+    getTemplates(): TemplateDefinition[];
+    getTemplate(id: string): TemplateDefinition | undefined;
+    clear(): void;
+}
+export declare const templateRegistry: TemplateRegistry;
+export {};

package/dist/cli/template-registry.js

@@ -0,0 +1,16 @@
+class TemplateRegistry {
+    templates = new Map();
+    register(template) {
+        this.templates.set(template.id, template);
+    }
+    getTemplates() {
+        return Array.from(this.templates.values());
+    }
+    getTemplate(id) {
+        return this.templates.get(id);
+    }
+    clear() {
+        this.templates.clear();
+    }
+}
+export const templateRegistry = new TemplateRegistry();

package/dist/cli.js

@@ -1,10 +1,8 @@
 #!/usr/bin/env node
 import path from "node:path";
-import fs from "node:fs";
-import { pathToFileURL } from "node:url";
-import { createRequire } from "node:module";
 import { aggregateDecls } from "./dsl/aggregator.js";
 import { registerBuiltins, runMapper } from "./mappers/index.js";
+import { loadExtensions } from "./cli/extensions.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) {
@@ -46,6 +44,17 @@ Examples:
         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 rawArgs = process.argv.slice(2);
+    const extFlags = rawArgs.filter(a => a.startsWith("--ext="));
+    const extModules = extFlags.flatMap(f => f.replace("--ext=", "").split(",")).filter(Boolean);
+    await loadExtensions(extModules);
     if (process.argv[2] === "check") {
         const { runCheck } = await import("./cli/check.js");
         await runCheck(process.argv.slice(3));
@@ -61,13 +70,6 @@ Examples:
         await runInit(process.argv.slice(3));
         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)
@@ -75,9 +77,6 @@ Examples:
     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];
@@ -198,49 +197,7 @@ Examples:
         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();
-        const require = createRequire(import.meta.url);
-        const pickExtensionFn = (mod) => {
-            const candidate = (mod?.default ?? mod?.extension ?? mod);
-            if (typeof candidate === "function")
-                return candidate;
-            if (candidate && typeof candidate === "object") {
-                if (typeof candidate.default === "function")
-                    return candidate.default;
-                if (typeof candidate.extension === "function")
-                    return candidate.extension;
-            }
-            return null;
-        };
-        const resolveExtensionModule = (spec) => {
-            const isPathLike = path.isAbsolute(spec) || spec.startsWith(".") || spec.startsWith("/") || /^[A-Za-z]:[\\/]/.test(spec);
-            if (isPathLike) {
-                const abs = path.isAbsolute(spec) ? spec : path.resolve(process.cwd(), spec);
-                if (!fs.existsSync(abs)) {
-                    throw new Error(`extension module not found: ${spec}`);
-                }
-                return pathToFileURL(abs).href;
-            }
-            const resolved = require.resolve(spec, { paths: [process.cwd()] });
-            return pathToFileURL(resolved).href;
-        };
-        for (const modPath of extModules) {
-            const modUrl = resolveExtensionModule(modPath);
-            const imported = await import(modUrl);
-            const fn = pickExtensionFn(imported);
-            if (typeof fn === "function") {
-                await fn(ctx, imported.options ?? undefined);
-            }
-            else {
-                console.warn(`extension module ${modPath} did not export a function`);
-            }
-        }
-    }
-    await loadExtensions();
+    await loadExtensions(extModules);
     const bundlePolicies = unified?.meta?.policies;
     const pickPolicy = (src, target) => {
         if (!src)

package/dist/dsl/frontend-runtime.js

@@ -3,6 +3,7 @@ import { pathToFileURL } from "node:url";
 import { DeclFrontendAppSchema } from "../ir/decl/frontend.raw.schema.js";
 // Use globalThis to share state across multiple module instances (e.g., src vs dist)
 const _global = globalThis;
+_global.__IR_FRONTEND_APPS = _global.__IR_FRONTEND_APPS || [];
 _global.__IR_CURRENT_FRONTEND = _global.__IR_CURRENT_FRONTEND || null;
 function assert(cond, msg) {
     if (!cond)
@@ -212,12 +213,14 @@ export function frontend(name, optsOrFn, maybeFn) {
     });
     const parsed = DeclFrontendAppSchema.parse(_global.__IR_CURRENT_FRONTEND);
     _global.__IR_CURRENT_FRONTEND = parsed;
+    _global.__IR_FRONTEND_APPS.push(parsed);
     return parsed;
 }
 export async function loadFrontendDsl(entry) {
     const abs = path.resolve(process.cwd(), entry);
     const url = pathToFileURL(abs).href;
     // reset
+    _global.__IR_FRONTEND_APPS = [];
     _global.__IR_CURRENT_FRONTEND = null;
     try {
         // Add cache buster to force re-execution if file is already in module cache
@@ -246,8 +249,7 @@ export async function loadFrontendDsl(entry) {
             throw new Error(`Failed to load frontend DSL (${entry}): ${err2?.message ?? err2}`);
         }
     }
-    if (!_global.__IR_CURRENT_FRONTEND)
+    if (_global.__IR_FRONTEND_APPS.length === 0)
         throw new Error(`Frontend DSL did not call frontend(...)`);
-    const parsed = DeclFrontendAppSchema.parse(_global.__IR_CURRENT_FRONTEND);
-    return parsed;
+    return _global.__IR_FRONTEND_APPS.length === 1 ? _global.__IR_FRONTEND_APPS[0] : _global.__IR_FRONTEND_APPS;
 }

package/dist/dsl/validator-registry.d.ts

@@ -0,0 +1,11 @@
+import { DeclBundle } from "../ir/decl/index.js";
+import { ValidationMessage } from "./validator.js";
+export type ValidatorFn = (bundle: DeclBundle) => ValidationMessage[];
+declare class ValidatorRegistry {
+    private validators;
+    register(id: string, validator: ValidatorFn): void;
+    getValidators(): ValidatorFn[];
+    clear(): void;
+}
+export declare const validatorRegistry: ValidatorRegistry;
+export {};

package/dist/dsl/validator-registry.js

@@ -0,0 +1,13 @@
+class ValidatorRegistry {
+    validators = new Map();
+    register(id, validator) {
+        this.validators.set(id, validator);
+    }
+    getValidators() {
+        return Array.from(this.validators.values());
+    }
+    clear() {
+        this.validators.clear();
+    }
+}
+export const validatorRegistry = new ValidatorRegistry();

package/dist/dsl/validator.js

@@ -1,3 +1,4 @@
+import { validatorRegistry } from "./validator-registry.js";
 export function validateSemantics(bundle) {
     const messages = [];
     const entities = new Set();
@@ -67,5 +68,19 @@ export function validateSemantics(bundle) {
             }
         }
     }
+    // 4. Extension Validators (New in v0.3.1)
+    const extValidators = validatorRegistry.getValidators();
+    for (const v of extValidators) {
+        try {
+            const extMessages = v(bundle);
+            messages.push(...extMessages);
+        }
+        catch (err) {
+            messages.push({
+                type: "warning",
+                message: `Extension validator failed: ${err.message}`
+            });
+        }
+    }
     return messages;
 }

package/dist/extensions/context.d.ts

@@ -3,6 +3,9 @@ import { engine as loweringEngine } from "../lowering/engine.js";
 import { emitterEngine } from "../emit/engine.js";
 import { registerTargetEmitter } from "../emit/registry.js";
 import * as frontendRegistry from "../emit/frontend/registry.js";
+import { ValidatorFn } from "../dsl/validator-registry.js";
+import { TemplateDefinition } from "../cli/template-registry.js";
+import { Logger } from "../utils/logger.js";
 export type ExtensionContext = {
     registerMapper: typeof registerMapper;
     unregisterMapper: typeof unregisterMapper;
@@ -16,7 +19,11 @@ export type ExtensionContext = {
     registerEnvelopeAdapter: typeof frontendRegistry.envelopeAdapters.register;
     registerPaginationAdapter: typeof frontendRegistry.paginationAdapters.register;
     registerUIComponent: typeof frontendRegistry.uiComponents.register;
+    registerValidator: (id: string, fn: ValidatorFn) => void;
+    registerTemplate: (template: TemplateDefinition) => void;
+    logger: Logger;
     namespace: (ns: string) => ExtensionContext;
+    root: ExtensionContext;
 };
 export declare function createExtensionContext(): ExtensionContext;
 export type { MapperFn } from "../types/extension.js";

package/dist/extensions/context.js

@@ -3,6 +3,9 @@ import { engine as loweringEngine } from "../lowering/engine.js";
 import { emitterEngine } from "../emit/engine.js";
 import { registerTargetEmitter } from "../emit/registry.js";
 import * as frontendRegistry from "../emit/frontend/registry.js";
+import { validatorRegistry } from "../dsl/validator-registry.js";
+import { templateRegistry } from "../cli/template-registry.js";
+import { logger as baseLogger } from "../utils/logger.js";
 function namespaced(ctx, ns) {
     const prefix = (name) => (name.includes(":") ? name : `${ns}:${name}`);
     return {
@@ -19,11 +22,16 @@ function namespaced(ctx, ns) {
         registerEnvelopeAdapter: (id, item, options) => ctx.registerEnvelopeAdapter(prefix(id), item, options),
         registerPaginationAdapter: (id, item, options) => ctx.registerPaginationAdapter(prefix(id), item, options),
         registerUIComponent: (id, item, options) => ctx.registerUIComponent(prefix(id), item, options),
+        registerValidator: (id, fn) => ctx.registerValidator(prefix(id), fn),
+        registerTemplate: (template) => ctx.registerTemplate({ ...template, id: prefix(template.id) }),
+        logger: ctx.logger.child(ns),
         namespace: (child) => namespaced(ctx, `${ns}:${child}`),
+        root: ctx.root,
     };
 }
 export function createExtensionContext() {
-    const base = {
+    const base = {};
+    return Object.assign(base, {
         registerMapper,
         unregisterMapper,
         listMappers,
@@ -36,7 +44,10 @@ export function createExtensionContext() {
         registerEnvelopeAdapter: frontendRegistry.envelopeAdapters.register.bind(frontendRegistry.envelopeAdapters),
         registerPaginationAdapter: frontendRegistry.paginationAdapters.register.bind(frontendRegistry.paginationAdapters),
         registerUIComponent: frontendRegistry.uiComponents.register.bind(frontendRegistry.uiComponents),
+        registerValidator: (id, fn) => validatorRegistry.register(id, fn),
+        registerTemplate: (template) => templateRegistry.register(template),
+        logger: baseLogger,
         namespace: (ns) => namespaced(base, ns),
-    };
-    return base;
+        root: base,
+    });
 }

package/dist/ir/decl/bundle.js

@@ -1,6 +1,7 @@
 // Pure bundle constructor: only wraps values; merge/conflict resolution lives in aggregator/normalize.
 export function asBundle(apps, meta) {
-    const bundle = { apps: Array.isArray(apps) ? apps : [apps] };
+    const appsArr = Array.isArray(apps) ? apps : [apps];
+    const bundle = { apps: appsArr.flat() };
     if (meta)
         bundle.meta = meta;
     return bundle;

package/dist/ir/target/backend.policy.d.ts

@@ -437,12 +437,12 @@ export declare const BackendLoggingPolicySchema: z.ZodDefault<z.ZodObject<{
 }, "strip", z.ZodTypeAny, {
     enabled: boolean;
     format: "json" | "pretty";
-    level: "info" | "error" | "debug" | "warn";
+    level: "info" | "error" | "warn" | "debug";
     redact: string[];
 }, {
     enabled?: boolean | undefined;
     format?: "json" | "pretty" | undefined;
-    level?: "info" | "error" | "debug" | "warn" | undefined;
+    level?: "info" | "error" | "warn" | "debug" | undefined;
     redact?: string[] | undefined;
 }>>;
 export declare const BackendHealthPolicySchema: z.ZodDefault<z.ZodObject<{
@@ -770,12 +770,12 @@ export declare const BackendPolicySchema: z.ZodDefault<z.ZodObject<{
     }, "strip", z.ZodTypeAny, {
         enabled: boolean;
         format: "json" | "pretty";
-        level: "info" | "error" | "debug" | "warn";
+        level: "info" | "error" | "warn" | "debug";
         redact: string[];
     }, {
         enabled?: boolean | undefined;
         format?: "json" | "pretty" | undefined;
-        level?: "info" | "error" | "debug" | "warn" | undefined;
+        level?: "info" | "error" | "warn" | "debug" | undefined;
         redact?: string[] | undefined;
     }>>;
     health: z.ZodDefault<z.ZodObject<{
@@ -902,7 +902,7 @@ export declare const BackendPolicySchema: z.ZodDefault<z.ZodObject<{
     logging: {
         enabled: boolean;
         format: "json" | "pretty";
-        level: "info" | "error" | "debug" | "warn";
+        level: "info" | "error" | "warn" | "debug";
         redact: string[];
     };
     health: {
@@ -985,7 +985,7 @@ export declare const BackendPolicySchema: z.ZodDefault<z.ZodObject<{
     logging?: {
         enabled?: boolean | undefined;
         format?: "json" | "pretty" | undefined;
-        level?: "info" | "error" | "debug" | "warn" | undefined;
+        level?: "info" | "error" | "warn" | "debug" | undefined;
         redact?: string[] | undefined;
     } | undefined;
     health?: {