@holoscript/core 6.0.2 → 6.0.4

package/dist/compiler/index.js

@@ -1,71 +1,541 @@
-export { NodeToyMapper, mapNodeToyToShader } from '../chunk-IHOUYQIA.js';
 export { createReproducibilityContext, parseReproducibilityFlags } from '../chunk-5GLCTO44.js';
-export { GLTF_PIPELINE_TOOLS, registerGLTFTools } from '../chunk-F5LVGHNT.js';
-import { init_Native2DCompiler, init_A2AAgentCardCompiler, A2AAgentCardCompiler_exports, init_NIRCompiler, NIRCompiler_exports, Native2DCompiler_exports } from '../chunk-BO2OKHIY.js';
-export { CompilerBridge, Native2DCompiler, NextJSCompiler, USDZPipeline, bestCategoryForTraits, compilePipelineSource, compilePipelineSourceToNode, compilePipelineSourceToPython, compilePipelineToNode, compilePipelineToPython, quickSafetyCheck, runSafetyPass, selectModality, selectModalityForAll } from '../chunk-BO2OKHIY.js';
+export { GLTF_PIPELINE_TOOLS, registerGLTFTools } from '../chunk-OFKWH2IP.js';
+export { NodeToyMapper, mapNodeToyToShader } from '../chunk-IHOUYQIA.js';
+import { init_A2AAgentCardCompiler, A2AAgentCardCompiler_exports, init_NIRCompiler, NIRCompiler_exports } from '../chunk-T4NKMBDL.js';
+export { CompilerBridge, USDZPipeline, bestCategoryForTraits, compilePipelineSource, compilePipelineSourceToNode, compilePipelineSourceToPython, compilePipelineToNode, compilePipelineToPython, quickSafetyCheck, runSafetyPass, selectModality, selectModalityForAll } from '../chunk-T4NKMBDL.js';
 export { generateHullGeometry, generateMembraneGeometry, generateSplineGeometry } from '../chunk-HJJLD366.js';
 export { RemotionBridgeImpl as RemotionBridge } from '../chunk-YYXH45E2.js';
-export { SemanticSceneGraph } from '../chunk-ZGTGVSTZ.js';
-import '../chunk-CNVM7J3M.js';
+export { SemanticSceneGraph } from '../chunk-HYNTS5CP.js';
+import '../chunk-XD6IYDUX.js';
 export { COCOExporterImpl as COCOExporter } from '../chunk-Q56TT7IL.js';
-import { init_WebGPUCompiler, WebGPUCompiler_exports } from '../chunk-KUJRR4FJ.js';
-export { WebGPUCompiler } from '../chunk-KUJRR4FJ.js';
-import { init_DTDLCompiler, DTDLCompiler_exports } from '../chunk-ZL6VJ6SN.js';
-export { DTDLCompiler } from '../chunk-ZL6VJ6SN.js';
-import { init_URDFCompiler, URDFCompiler_exports } from '../chunk-7N3JIJMT.js';
-export { URDFCompiler } from '../chunk-7N3JIJMT.js';
-export { USDPhysicsCompiler } from '../chunk-AC4BSHFV.js';
-import { init_SDFCompiler, SDFCompiler_exports } from '../chunk-PLMYCCA4.js';
-export { SDFCompiler } from '../chunk-PLMYCCA4.js';
-import { init_StateCompiler, StateCompiler_exports } from '../chunk-BU5ZAFMC.js';
-export { StateCompiler } from '../chunk-BU5ZAFMC.js';
-export { TraitCompositionCompiler } from '../chunk-Y5MUAYTO.js';
-export { IncrementalCompiler } from '../chunk-CO2VM2DK.js';
-import { init_GodotCompiler, GodotCompiler_exports } from '../chunk-NLPSZT4C.js';
-export { GodotCompiler } from '../chunk-NLPSZT4C.js';
-import { init_R3FCompiler, R3FCompiler_exports } from '../chunk-HBZYCASG.js';
-export { ENVIRONMENT_PRESETS, R3FCompiler } from '../chunk-HBZYCASG.js';
-import '../chunk-ODGMVILH.js';
-import { init_PlayCanvasCompiler, PlayCanvasCompiler_exports } from '../chunk-NCUHGRTZ.js';
-export { PlayCanvasCompiler } from '../chunk-NCUHGRTZ.js';
-import { init_AndroidCompiler, AndroidCompiler_exports } from '../chunk-M6FU6S22.js';
-export { AndroidCompiler } from '../chunk-M6FU6S22.js';
-import { init_AndroidXRCompiler, AndroidXRCompiler_exports } from '../chunk-MWEFR6YQ.js';
-export { AndroidXRCompiler } from '../chunk-MWEFR6YQ.js';
-import { init_IOSCompiler, IOSCompiler_exports } from '../chunk-6OQBLABR.js';
-export { IOSCompiler } from '../chunk-6OQBLABR.js';
-import { init_VisionOSCompiler, VisionOSCompiler_exports } from '../chunk-74YCHHTE.js';
-export { VisionOSCompiler } from '../chunk-74YCHHTE.js';
-import { init_WASMCompiler, WASMCompiler_exports } from '../chunk-65RFOWZI.js';
-export { WASMCompiler } from '../chunk-65RFOWZI.js';
-export { MultiLayerCompiler } from '../chunk-NKRKT6V2.js';
-import { init_VRRCompiler, VRRCompiler_exports } from '../chunk-VK5AXKO3.js';
-import { init_ARCompiler, ARCompiler_exports } from '../chunk-6WNCRE6F.js';
-export { ARCompiler } from '../chunk-6WNCRE6F.js';
-import { init_OpenXRCompiler, OpenXRCompiler_exports } from '../chunk-C7BNX4XJ.js';
-export { OpenXRCompiler } from '../chunk-C7BNX4XJ.js';
-import { init_VRChatCompiler, VRChatCompiler_exports } from '../chunk-4FCZDTD5.js';
-export { VRChatCompiler } from '../chunk-4FCZDTD5.js';
-import { init_BabylonCompiler, BabylonCompiler_exports } from '../chunk-ELLQPFAF.js';
-export { BabylonCompiler } from '../chunk-ELLQPFAF.js';
-import '../chunk-UQW6SLM5.js';
-import '../chunk-XSF76QRU.js';
-import { init_UnityCompiler, UnityCompiler_exports } from '../chunk-HUFNKFA6.js';
-export { UnityCompiler } from '../chunk-HUFNKFA6.js';
-import { init_UnrealCompiler, UnrealCompiler_exports } from '../chunk-W76ETJTI.js';
-import '../chunk-KDB6BUMB.js';
-import { init_CompilerBase, init_ANSNamespace, CompilerBase, ANSCapabilityPath, init_CompilerDocumentationGenerator } from '../chunk-QWKUKVRE.js';
-export { CompilerBase, CompilerDocumentationGenerator, UnauthorizedCompilerAccessError, createTestCompilerToken, isCapabilityTokenCredential } from '../chunk-QWKUKVRE.js';
-import '../chunk-V42NTCFH.js';
+import { init_DTDLCompiler, DTDLCompiler_exports } from '../chunk-IWI6J7FX.js';
+export { DTDLCompiler } from '../chunk-IWI6J7FX.js';
+import { init_URDFCompiler, URDFCompiler_exports } from '../chunk-UPJBDCVF.js';
+export { URDFCompiler } from '../chunk-UPJBDCVF.js';
+export { USDPhysicsCompiler } from '../chunk-SDAMZIRE.js';
+import { init_SDFCompiler, SDFCompiler_exports } from '../chunk-UERJ3YJV.js';
+export { SDFCompiler } from '../chunk-UERJ3YJV.js';
+import { init_StateCompiler, StateCompiler_exports } from '../chunk-CDPGV4DN.js';
+export { StateCompiler } from '../chunk-CDPGV4DN.js';
+export { TraitCompositionCompiler } from '../chunk-NOZZ46QU.js';
+export { IncrementalCompiler } from '../chunk-CS2EMTGF.js';
+import { init_R3FCompiler, R3FCompiler_exports } from '../chunk-T36DDXSF.js';
+export { ENVIRONMENT_PRESETS, R3FCompiler } from '../chunk-T36DDXSF.js';
+import '../chunk-H5Z7NASB.js';
+import { init_PlayCanvasCompiler, PlayCanvasCompiler_exports } from '../chunk-S565K7NK.js';
+export { PlayCanvasCompiler } from '../chunk-S565K7NK.js';
+import { init_AndroidCompiler, AndroidCompiler_exports } from '../chunk-QGKNANZ3.js';
+export { AndroidCompiler } from '../chunk-QGKNANZ3.js';
+import { init_AndroidXRCompiler, AndroidXRCompiler_exports } from '../chunk-S2N5TNMA.js';
+export { AndroidXRCompiler } from '../chunk-S2N5TNMA.js';
+import { init_IOSCompiler, IOSCompiler_exports } from '../chunk-BWFJEM5A.js';
+export { IOSCompiler } from '../chunk-BWFJEM5A.js';
+import { init_VisionOSCompiler, VisionOSCompiler_exports } from '../chunk-YCXFCXDS.js';
+export { VisionOSCompiler } from '../chunk-YCXFCXDS.js';
+import { init_WASMCompiler, WASMCompiler_exports } from '../chunk-L4G4RLXX.js';
+export { WASMCompiler } from '../chunk-L4G4RLXX.js';
+import { init_WebGPUCompiler, WebGPUCompiler_exports } from '../chunk-G4VZTCIB.js';
+export { WebGPUCompiler } from '../chunk-G4VZTCIB.js';
+export { MultiLayerCompiler } from '../chunk-FHQVYCH2.js';
+import { init_ARCompiler, ARCompiler_exports } from '../chunk-MEASWI2Y.js';
+export { ARCompiler } from '../chunk-MEASWI2Y.js';
+import { init_OpenXRCompiler, OpenXRCompiler_exports } from '../chunk-XCWFGZAA.js';
+export { OpenXRCompiler } from '../chunk-XCWFGZAA.js';
+import { init_VRChatCompiler, VRChatCompiler_exports } from '../chunk-E3FWRT3Z.js';
+export { VRChatCompiler } from '../chunk-E3FWRT3Z.js';
+import { init_BabylonCompiler, BabylonCompiler_exports } from '../chunk-KED34ILP.js';
+export { BabylonCompiler } from '../chunk-KED34ILP.js';
+import '../chunk-A7PIMZGU.js';
+import '../chunk-DXJQDCFL.js';
+import { init_UnityCompiler, UnityCompiler_exports } from '../chunk-TEWCN33Y.js';
+export { UnityCompiler } from '../chunk-TEWCN33Y.js';
+import { init_UnrealCompiler, UnrealCompiler_exports } from '../chunk-RVYPEYPX.js';
+import { init_GodotCompiler, GodotCompiler_exports } from '../chunk-K6EKD26I.js';
+export { GodotCompiler } from '../chunk-K6EKD26I.js';
 import '../chunk-56IF4NTA.js';
-import '../chunk-26TLYBFD.js';
-import '../chunk-SUCBB66F.js';
-import '../chunk-XNMEH2BI.js';
-import { __export, __esm, __toCommonJS } from '../chunk-32TWR3HE.js';
+import { init_constants, CONNECTOR_PACKAGES, CONNECTOR_ENV_REQUIREMENTS, KNOWN_CONNECTORS } from '../chunk-NDQNIJEH.js';
+import '../chunk-IFNQFCTM.js';
+import '../chunk-HPS76H7Q.js';
+import '../chunk-WB4Z63GG.js';
+import '../chunk-XUTX5CBW.js';
+import { init_VRRCompiler, VRRCompiler_exports } from '../chunk-R7MA7QWV.js';
+import '../chunk-YQK5JNFK.js';
+import { init_CompilerBase, CompilerBase, init_identity, ANSCapabilityPath, init_CompilerDocumentationGenerator } from '../chunk-6XSERL6L.js';
+export { CompilerBase, CompilerDocumentationGenerator, UnauthorizedCompilerAccessError, createTestCompilerToken, isCapabilityTokenCredential } from '../chunk-6XSERL6L.js';
+import { __export, __esm, __toCommonJS } from '../chunk-2CWOLHTE.js';
+
+// src/compiler/Native2DCompiler.ts
+var Native2DCompiler_exports = {};
+__export(Native2DCompiler_exports, {
+  Native2DCompiler: () => Native2DCompiler
+});
+var Native2DCompiler;
+var init_Native2DCompiler = __esm({
+  "src/compiler/Native2DCompiler.ts"() {
+    init_CompilerBase();
+    Native2DCompiler = class extends CompilerBase {
+      constructor() {
+        super(...arguments);
+        this.compilerName = "Native2DCompiler";
+        // ============================================================================
+        // REACT GENERATION
+        // ============================================================================
+        /** Collected during node traversal — used to generate imports and hooks */
+        this._slotImports = /* @__PURE__ */ new Map();
+        this._uiImports = /* @__PURE__ */ new Set();
+        this._stateFields = /* @__PURE__ */ new Map();
+        this._fetchCalls = [];
+        this._options = {};
+      }
+      // @ts-expect-error During migration
+      compile(composition, agentToken, outputPath, options) {
+        this.validateCompilerAccess(agentToken, outputPath);
+        const isReact = options?.format === "react";
+        const elements = composition.ui?.elements || composition.objects || [];
+        if (isReact) {
+          const code = this.generateReactComponent(composition.name, elements, composition, options);
+          if (options?.generateDocs) {
+            return {
+              output: code,
+              documentation: this.generateDocumentation(composition, code, options.docsOptions)
+            };
+          }
+          return code;
+        } else {
+          const code = this.generateHTMLPage(composition.name, elements, composition);
+          if (options?.generateDocs) {
+            return {
+              output: code,
+              documentation: this.generateDocumentation(composition, code, options.docsOptions)
+            };
+          }
+          return code;
+        }
+      }
+      generateReactComponent(name, objects, composition, options) {
+        this._slotImports.clear();
+        this._uiImports.clear();
+        this._stateFields.clear();
+        this._fetchCalls = [];
+        this._options = options || {};
+        const safeName = name.replace(/[^a-zA-Z0-9]/g, "");
+        if (composition?.state?.properties) {
+          for (const prop of composition.state.properties) {
+            this._stateFields.set(prop.key, prop.value ?? null);
+          }
+        }
+        const jsx = objects.map((obj) => this.generateReactNode(obj)).join("\n        ");
+        const imports = [];
+        const reactImports = /* @__PURE__ */ new Set();
+        if (this._stateFields.size > 0) reactImports.add("useState");
+        if (this._fetchCalls.length > 0) reactImports.add("useEffect");
+        imports.push(
+          reactImports.size > 0 ? `import React, { ${[...reactImports].join(", ")} } from 'react';` : `import React from 'react';`
+        );
+        if (this._uiImports.size > 0) {
+          imports.push(`import { ${[...this._uiImports].join(", ")} } from '@holoscript/ui';`);
+        }
+        for (const [, slot] of this._slotImports) {
+          imports.push(`import { ${slot.component} } from '${slot.importPath}';`);
+        }
+        const stateHooks = [];
+        for (const [key, value] of this._stateFields) {
+          const capitalKey = key.charAt(0).toUpperCase() + key.slice(1);
+          const initValue = JSON.stringify(value);
+          stateHooks.push(
+            `  const [${key}, set${capitalKey}] = useState(${initValue === void 0 ? "null" : initValue});`
+          );
+        }
+        const fetchEffects = [];
+        for (const f of this._fetchCalls) {
+          fetchEffects.push(`  useEffect(() => {
+    fetch(\`${f.endpoint}\`${f.method !== "GET" ? `, { method: '${f.method}' }` : ""})
+      .then(r => r.json())
+      .then(set${f.name.charAt(0).toUpperCase() + f.name.slice(1)})
+      .catch(console.error);
+  }, []);`);
+        }
+        return `${imports.join("\n")}
+
+// @generated by HoloScript Native2DCompiler \u2014 DO NOT EDIT
+export function ${safeName}Component() {
+${stateHooks.join("\n")}
+${fetchEffects.join("\n")}
+
+  return (
+    <div className="holoscript-2d-root w-full h-full">
+      ${jsx}
+    </div>
+  );
+}
+
+export default ${safeName}Component;
+`;
+      }
+      generateReactNode(obj) {
+        const traits = this.extractTraits(obj);
+        if (traits.slot) {
+          const slotName = traits.slot.name || obj.name || "Slot";
+          const configuredSlot = this._options.slots?.[String(slotName)];
+          const component = traits.slot.component || configuredSlot?.component || slotName;
+          const importPath = traits.slot.import || configuredSlot?.importPath || `@/components/${component}`;
+          this._slotImports.set(slotName, { component, importPath });
+          const propsStr = traits.slot.props ? ` {...${JSON.stringify(traits.slot.props)}}` : "";
+          return `<div data-holo-slot="${slotName}">
+        <${component}${propsStr} />
+      </div>`;
+        }
+        if (traits.fetch) {
+          const name = traits.fetch.into || "data";
+          const endpoint = traits.fetch.endpoint || "/api/data";
+          const method = traits.fetch.method || "GET";
+          this._fetchCalls.push({ name, endpoint, method });
+          if (!this._stateFields.has(name)) {
+            this._stateFields.set(name, null);
+          }
+        }
+        let tag = traits.theme?.tag || traits.panel?.tag || (typeof obj.type === "string" ? obj.type.toLowerCase() : void 0) || "div";
+        if ([
+          "nav",
+          "section",
+          "main",
+          "footer",
+          "form",
+          "style",
+          "a",
+          "header",
+          "h1",
+          "h2",
+          "h3"
+        ].includes(tag)) ; else if (tag === "container") {
+          tag = "div";
+        } else if (traits.link || tag === "link") {
+          tag = "a";
+        } else if (traits.button || tag === "button") {
+          tag = "button";
+        } else if (traits.image || tag === "image") {
+          tag = "img";
+        } else if (traits.input || tag === "input") {
+          tag = "input";
+        } else if (traits.text || tag === "text") {
+          tag = this.mapTextVariantToTag(traits.text?.variant || "body");
+        } else {
+          tag = "div";
+        }
+        const styles = this.buildStyles(traits);
+        const classes = this.buildClasses(traits);
+        let props = ``;
+        if (traits.theme?.className) {
+          classes.push(traits.theme.className);
+        }
+        if (traits.theme?.id) {
+          props += ` id="${traits.theme.id}"`;
+        }
+        const combinedStyles = { ...styles };
+        if (traits.theme?.style) {
+          traits.theme.style.split(";").forEach((rule) => {
+            const [key, ...valueParts] = rule.split(":");
+            const value = valueParts.join(":");
+            if (key && value) {
+              const camelKey = key.trim().replace(/-([a-z])/g, (g) => g[1].toUpperCase());
+              combinedStyles[camelKey] = value.trim();
+            }
+          });
+        }
+        if (Object.keys(combinedStyles).length > 0) {
+          props += ` style={${JSON.stringify(combinedStyles)}}`;
+        }
+        if (classes.length > 0) {
+          props += ` className="${classes.join(" ")}"`;
+        }
+        if (traits.theme?.attributes) {
+          try {
+            const parsedAttrs = JSON.parse(traits.theme.attributes);
+            for (const [key, value] of Object.entries(parsedAttrs)) {
+              props += ` ${key}="${value}"`;
+            }
+          } catch (e) {
+          }
+        }
+        if (traits.button?.onClick || traits.form?.onSubmit) {
+          const action = traits.button?.onClick || traits.form?.onSubmit;
+          if (action) {
+            const cleanAction = action.replace(/["']/g, "'");
+            if (cleanAction.includes("navigate")) {
+              props += ` onClick={() => ${cleanAction}}`;
+            } else if (cleanAction.includes("submit")) {
+              props += ` onSubmit={${cleanAction}}`;
+            } else if (cleanAction.includes("window.open")) {
+              props += ` onClick={() => ${cleanAction}}`;
+            } else {
+              props += ` onClick={() => console.log('${cleanAction}')}`;
+            }
+          }
+        }
+        if (traits.image?.src) props += ` src="${traits.image.src}"`;
+        if (traits.image?.alt) props += ` alt="${traits.image.alt}"`;
+        if (traits.link?.href) props += ` href="${traits.link.href}"`;
+        if (traits.input?.placeholder) props += ` placeholder="${traits.input.placeholder}"`;
+        if (traits.input?.type) props += ` type="${traits.input.type}"`;
+        if (traits.input?.required) props += ` required`;
+        if (traits.button?.type) props += ` type="${traits.button.type}"`;
+        const childrenMarkup = (obj.children || obj.objects || []).map((child) => this.generateReactNode(child)).join("\n");
+        const content = traits.text?.content || traits.button?.content || traits.link?.content || traits.icon?.name;
+        let safeContent = "";
+        if (content) {
+          safeContent = `{\`${content.replace(/`/g, "\\`").replace(/\$/g, "\\$")}\`}`;
+        }
+        if (tag === "style") {
+          const escapedStyle = (content || "").replace(/`/g, "\\`").replace(/\$/g, "\\$");
+          return `<style dangerouslySetInnerHTML={{ __html: \`${escapedStyle}\` }} />`;
+        }
+        if (tag === "img" || tag === "input") {
+          return `<${tag}${props} />`;
+        }
+        return `<${tag}${props}>
+      ${safeContent}
+      ${childrenMarkup}
+    </${tag}>`;
+      }
+      // ============================================================================
+      // HTML GENERATION
+      // ============================================================================
+      generateHTMLPage(name, objects, composition) {
+        const content = objects.map((obj) => this.generateHTMLNode(obj)).join("\n      ");
+        let bgColor = "#ffffff";
+        let color = "#000000";
+        if (composition.environment?.properties) {
+          const themeProp = composition.environment.properties.find((p) => p.key === "theme");
+          const bgProp = composition.environment.properties.find((p) => p.key === "backgroundColor");
+          if (themeProp?.value === "dark" || composition.traits?.some((t) => t.name === "theme" && t.config?.dark)) {
+            bgColor = bgProp?.value || "#050510";
+            color = "#ffffff";
+          }
+        }
+        return `<!DOCTYPE html>
+<html lang="en">
+<head>
+    <meta charset="UTF-8">
+    <meta name="viewport" content="width=device-width, initial-scale=1.0">
+    <title>${name}</title>
+    <script src="https://cdn.tailwindcss.com"></script>
+    <style>
+      body { margin: 0; padding: 0; background-color: ${bgColor}; color: ${color}; font-family: system-ui, -apple-system, sans-serif; }
+      /* Basic resets and custom trait animations to mirror React Framer variants */
+      .glow-btn:hover { box-shadow: 0 0 15px rgba(255,255,255,0.5); }
+      .lift-card { transition: transform 0.2s ease, box-shadow 0.2s ease; }
+      .lift-card:hover { transform: translateY(-4px); box-shadow: 0 10px 20px rgba(0,0,0,0.2); }
+    </style>
+</head>
+<body>
+    <div id="holoscript-native-root">
+      ${content}
+    </div>
+    <script>
+      function navigate(path) { window.location.href = path; }
+      function submitNewsletter(e) { e.preventDefault(); alert('Subscribed!'); }
+    </script>
+</body>
+</html>`;
+      }
+      generateHTMLNode(obj) {
+        const node = obj;
+        const traits = this.extractTraits(obj);
+        const nodeType = typeof node.type === "string" ? node.type.toLowerCase() : void 0;
+        let tag = traits.theme?.tag || traits.panel?.tag || nodeType || "div";
+        if ([
+          "nav",
+          "section",
+          "main",
+          "footer",
+          "form",
+          "style",
+          "a",
+          "header",
+          "h1",
+          "h2",
+          "h3"
+        ].includes(tag)) ; else if (tag === "container") {
+          tag = "div";
+        } else if (traits.link || tag === "link") {
+          tag = "a";
+        } else if (traits.button || tag === "button") {
+          tag = "button";
+        } else if (traits.image || tag === "image") {
+          tag = "img";
+        } else if (traits.input || tag === "input") {
+          tag = "input";
+        } else if (traits.text || tag === "text") {
+          tag = this.mapTextVariantToTag(traits.text?.variant || "body");
+        } else {
+          tag = "div";
+        }
+        const styles = this.buildStyles(traits);
+        const classes = this.buildClasses(traits);
+        let props = ``;
+        if (traits.theme?.className) {
+          classes.push(traits.theme.className);
+        }
+        if (traits.theme?.id) {
+          props += ` id="${traits.theme.id}"`;
+        }
+        if (Object.keys(styles).length > 0 || traits.theme?.style) {
+          let styleStr = Object.entries(styles).map(([k, v]) => `${this.camelToKebab(k)}: ${v}`).join("; ");
+          if (traits.theme?.style) {
+            styleStr += (styleStr ? "; " : "") + traits.theme.style;
+          }
+          props += ` style="${styleStr}"`;
+        }
+        if (classes.length > 0) {
+          props += ` class="${classes.join(" ")}"`;
+        }
+        if (traits.theme?.attributes) {
+          try {
+            const parsedAttrs = JSON.parse(traits.theme.attributes);
+            for (const [key, value] of Object.entries(parsedAttrs)) {
+              props += ` ${key}="${value}"`;
+            }
+          } catch (e) {
+          }
+        }
+        if (traits.button?.onClick) props += ` onclick="${traits.button.onClick}"`;
+        if (traits.form?.onSubmit) props += ` onsubmit="${traits.form.onSubmit}"`;
+        if (traits.image?.src) props += ` src="${traits.image.src}"`;
+        if (traits.image?.alt) props += ` alt="${traits.image.alt}"`;
+        if (traits.link?.href) props += ` href="${traits.link.href}"`;
+        if (traits.input?.placeholder) props += ` placeholder="${traits.input.placeholder}"`;
+        if (traits.input?.type) props += ` type="${traits.input.type}"`;
+        if (traits.input?.required) props += ` required`;
+        const children = node.children || node.objects || [];
+        const childrenMarkup = children.map((child) => this.generateHTMLNode(child)).join("\n");
+        const content = traits.text?.content || traits.button?.content || traits.link?.content || traits.icon?.name;
+        if (tag === "img" || tag === "input") {
+          return `<${tag}${props}>`;
+        }
+        return `<${tag}${props}>
+      ${content ? content : ""}
+      ${childrenMarkup}
+    </${tag}>`;
+      }
+      // ============================================================================
+      // UTILITIES
+      // ============================================================================
+      extractTraits(obj) {
+        const map = {};
+        const node = obj;
+        if (!node.traits) return map;
+        for (const t of node.traits) {
+          map[t.name] = t.config || {};
+          if (t.name === "tailwind" && typeof t.config === "string") {
+            map[t.name] = { classes: t.config };
+          }
+        }
+        return map;
+      }
+      mapTextVariantToTag(variant) {
+        switch (variant) {
+          case "h1":
+            return "h1";
+          case "h2":
+            return "h2";
+          case "h3":
+            return "h3";
+          case "subtitle":
+            return "h4";
+          case "caption":
+            return "span";
+          case "emoji":
+            return "span";
+          default:
+            return "p";
+        }
+      }
+      buildStyles(traits) {
+        const styles = {};
+        const layout = traits.layout;
+        const theme = traits.theme;
+        if (layout) {
+          if (layout.flex) {
+            styles.display = "flex";
+            styles.flexDirection = layout.flex === "row" ? "row" : "column";
+          }
+          if (layout.grid) {
+            styles.display = "grid";
+            styles.gridTemplateColumns = `repeat(${layout.columns || 1}, minmax(0, 1fr))`;
+          }
+          if (layout.justify) styles.justifyContent = layout.justify;
+          if (layout.align) styles.alignItems = layout.align;
+          if (layout.gap) styles.gap = typeof layout.gap === "number" ? `${layout.gap}px` : layout.gap;
+          if (layout.padding)
+            styles.padding = typeof layout.padding === "number" ? `${layout.padding}px` : layout.padding;
+        }
+        if (theme) {
+          if (theme.backgroundColor) styles.backgroundColor = theme.backgroundColor;
+          if (theme.color) styles.color = theme.color;
+          if (theme.padding)
+            styles.padding = typeof theme.padding === "number" ? `${theme.padding}px` : theme.padding;
+          if (theme.borderRadius)
+            styles.borderRadius = typeof theme.borderRadius === "number" ? `${theme.borderRadius}px` : theme.borderRadius;
+          if (theme.border) styles.border = theme.border;
+          if (theme.borderTop) styles.borderTop = theme.borderTop;
+        }
+        if (traits.text) {
+          if (traits.text.align) styles.textAlign = traits.text.align;
+          if (traits.text.maxWidth)
+            styles.maxWidth = typeof traits.text.maxWidth === "number" ? `${traits.text.maxWidth}px` : traits.text.maxWidth;
+          if (traits.text.weight) styles.fontWeight = traits.text.weight;
+        }
+        return styles;
+      }
+      buildClasses(traits) {
+        const classes = [];
+        if (traits.text) {
+          if (traits.text.variant === "h1") classes.push("text-5xl font-bold tracking-tight");
+          if (traits.text.variant === "h2") classes.push("text-3xl font-bold");
+          if (traits.text.variant === "h3") classes.push("text-xl font-semibold");
+          if (traits.text.variant === "subtitle") classes.push("text-xl text-gray-400");
+          if (traits.text.variant === "caption") classes.push("text-sm text-gray-500");
+          if (traits.text.variant === "emoji") classes.push("text-2xl");
+        }
+        if (traits.button) {
+          classes.push("px-4 py-2 rounded-lg font-medium transition-all");
+          if (traits.button.variant === "primary")
+            classes.push("bg-blue-600 hover:bg-blue-700 text-white");
+          if (traits.button.variant === "outline")
+            classes.push("border border-gray-600 hover:bg-gray-800 text-white");
+          if (traits.button.variant === "ghost")
+            classes.push("hover:bg-gray-800 text-gray-300 hover:text-white");
+          if (traits.button.variant === "glow")
+            classes.push("bg-indigo-600 text-white glow-btn hover:bg-indigo-500");
+          if (traits.button.size === "lg") classes.push("px-6 py-3 text-lg");
+          if (traits.button.size === "sm") classes.push("px-3 py-1 text-sm");
+        }
+        if (traits.card) {
+          if (traits.card.shadow === "md") classes.push("shadow-md");
+          if (traits.card.shadow === "lg") classes.push("shadow-lg");
+          if (traits.card.hover === "glow") classes.push("lift-card");
+        }
+        if (traits.input) {
+          classes.push(
+            "px-4 py-2 rounded-lg border border-gray-700 bg-gray-900 text-white focus:ring-2 focus:ring-indigo-500 outline-none"
+          );
+        }
+        if (traits.tailwind?.classes) {
+          classes.push(traits.tailwind.classes);
+        }
+        return classes;
+      }
+      camelToKebab(str) {
+        return str.replace(/([a-z0-9])([A-Z])/g, "$1-$2").toLowerCase();
+      }
+    };
+  }
+});
 
 // src/compiler/NextJSAPICompiler.ts
 var NextJSAPICompiler_exports = {};
 __export(NextJSAPICompiler_exports, {
+  NextJSAPICompiler: () => NextJSAPICompiler,
   compileAllToNextJSAPI: () => compileAllToNextJSAPI,
   compileToNextJSAPI: () => compileToNextJSAPI
 });
@@ -122,9 +592,7 @@ function extractHandlers(composition) {
     const rawMethod = toScalar(traitConfig["method"]) ?? props.get("method");
     const method = parseMethod(rawMethod);
     if (!method) continue;
-    const traitStatus = toScalar(
-      traitConfig["statusCode"] ?? traitConfig["status"]
-    );
+    const traitStatus = toScalar(traitConfig["statusCode"] ?? traitConfig["status"]);
     const propStatus = props.get("statusCode") ?? props.get("status");
     byMethod.set(method, {
       method,
@@ -216,634 +684,76 @@ function compileToNextJSAPI(composition, options = {}) {
 function compileAllToNextJSAPI(compositions, options = {}) {
   return compositions.map(({ composition }) => compileToNextJSAPI(composition, options));
 }
-var VALID_METHODS, BODY_METHODS, PASSTHROUGH_METHODS;
+var VALID_METHODS, BODY_METHODS, PASSTHROUGH_METHODS, NextJSAPICompiler;
 var init_NextJSAPICompiler = __esm({
   "src/compiler/NextJSAPICompiler.ts"() {
-    VALID_METHODS = /* @__PURE__ */ new Set(["GET", "POST", "PUT", "PATCH", "DELETE", "HEAD", "OPTIONS"]);
+    init_CompilerBase();
+    VALID_METHODS = /* @__PURE__ */ new Set([
+      "GET",
+      "POST",
+      "PUT",
+      "PATCH",
+      "DELETE",
+      "HEAD",
+      "OPTIONS"
+    ]);
     BODY_METHODS = /* @__PURE__ */ new Set(["POST", "PUT", "PATCH"]);
     PASSTHROUGH_METHODS = /* @__PURE__ */ new Set(["HEAD", "DELETE"]);
+    NextJSAPICompiler = class extends CompilerBase {
+      constructor(options = {}) {
+        super();
+        this.options = options;
+      }
+      get name() {
+        return "nextjs-api";
+      }
+      compile(composition, agentToken) {
+        const comp = composition;
+        const result = compileAllToNextJSAPI(comp);
+        return {
+          code: result.map((r) => r.code).join("\n\n"),
+          files: result.map((r) => ({ path: r.routePath, content: r.code }))
+        };
+      }
+      compileSingle(composition, agentToken) {
+        const comp = composition;
+        return compileToNextJSAPI(comp);
+      }
+    };
   }
 });
 
-// src/compiler/registerBuiltinDialects.ts
-var registerBuiltinDialects_exports = {};
-__export(registerBuiltinDialects_exports, {
-  registerBuiltinDialects: () => registerBuiltinDialects
+// src/compiler/NodeServiceCompiler.ts
+var NodeServiceCompiler_exports = {};
+__export(NodeServiceCompiler_exports, {
+  NodeServiceCompiler: () => NodeServiceCompiler
 });
-function registerBuiltinDialects() {
-  if (_registered) return;
-  _registered = true;
-  const descriptors = [
-    // ── Game Engines ──────────────────────────────────────────────────────
-    {
-      name: "unity",
-      domain: "gamedev",
-      description: "Compiles to Unity C# MonoBehaviours",
-      supportedTraits: [
-        "physics",
-        "collidable",
-        "grabbable",
-        "throwable",
-        "audio",
-        "spatial_audio",
-        "animation",
-        "particles",
-        "material",
-        "ui",
-        "networked",
-        "behavior_tree",
-        "navmesh",
-        "lod"
-      ],
-      riskTier: "standard",
-      factory: (opts) => {
-        const { UnityCompiler: UnityCompiler2 } = (init_UnityCompiler(), __toCommonJS(UnityCompiler_exports));
-        return new UnityCompiler2(opts);
-      },
-      outputExtensions: [".cs"]
-    },
-    {
-      name: "unreal",
-      domain: "gamedev",
-      description: "Compiles to Unreal Engine C++ actors",
-      supportedTraits: [
-        "physics",
-        "collidable",
-        "grabbable",
-        "audio",
-        "animation",
-        "particles",
-        "material",
-        "niagara",
-        "landscape",
-        "behavior_tree",
-        "navmesh",
-        "lod"
-      ],
-      riskTier: "standard",
-      factory: (opts) => {
-        const { UnrealCompiler } = (init_UnrealCompiler(), __toCommonJS(UnrealCompiler_exports));
-        return new UnrealCompiler(opts);
-      },
-      outputExtensions: [".cpp", ".h"]
-    },
-    {
-      name: "godot",
-      domain: "gamedev",
-      description: "Compiles to Godot GDScript nodes",
-      supportedTraits: [
-        "physics",
-        "collidable",
-        "grabbable",
-        "audio",
-        "animation",
-        "particles",
-        "material",
-        "behavior_tree",
-        "navmesh"
-      ],
-      riskTier: "standard",
-      factory: (opts) => {
-        const { GodotCompiler: GodotCompiler2 } = (init_GodotCompiler(), __toCommonJS(GodotCompiler_exports));
-        return new GodotCompiler2(opts);
-      },
-      outputExtensions: [".gd", ".tscn"]
-    },
-    // ── Web 3D ────────────────────────────────────────────────────────────
-    {
-      name: "r3f",
-      domain: "web3d",
-      description: "Compiles to React Three Fiber JSX components",
-      supportedTraits: [
-        "physics",
-        "collidable",
-        "grabbable",
-        "audio",
-        "spatial_audio",
-        "animation",
-        "particles",
-        "material",
-        "ui",
-        "behavior_tree",
-        "lod",
-        "vr_only",
-        "ar_only"
-      ],
-      riskTier: "standard",
-      factory: (opts) => {
-        const { R3FCompiler: R3FCompiler2 } = (init_R3FCompiler(), __toCommonJS(R3FCompiler_exports));
-        return new R3FCompiler2(opts);
-      },
-      outputExtensions: [".tsx", ".jsx"]
-    },
-    {
-      name: "babylon",
-      domain: "web3d",
-      description: "Compiles to Babylon.js scene code",
-      supportedTraits: [
-        "physics",
-        "collidable",
-        "audio",
-        "animation",
-        "particles",
-        "material",
-        "behavior_tree"
-      ],
-      riskTier: "standard",
-      factory: (opts) => {
-        const { BabylonCompiler: BabylonCompiler2 } = (init_BabylonCompiler(), __toCommonJS(BabylonCompiler_exports));
-        return new BabylonCompiler2(opts);
-      },
-      outputExtensions: [".ts", ".js"]
-    },
-    {
-      name: "playcanvas",
-      domain: "web3d",
-      description: "Compiles to PlayCanvas engine scripts",
-      supportedTraits: ["physics", "collidable", "audio", "animation", "material"],
-      riskTier: "standard",
-      factory: (opts) => {
-        const { PlayCanvasCompiler: PlayCanvasCompiler2 } = (init_PlayCanvasCompiler(), __toCommonJS(PlayCanvasCompiler_exports));
-        return new PlayCanvasCompiler2(opts);
-      },
-      outputExtensions: [".js"]
-    },
-    // ── VR/XR ─────────────────────────────────────────────────────────────
-    {
-      name: "openxr",
-      domain: "xr",
-      description: "Compiles to OpenXR C++ application layer",
-      supportedTraits: [
-        "physics",
-        "hand_tracking",
-        "spatial_anchor",
-        "input",
-        "collidable",
-        "grabbable"
-      ],
-      riskTier: "standard",
-      factory: (opts) => {
-        const { OpenXRCompiler: OpenXRCompiler2 } = (init_OpenXRCompiler(), __toCommonJS(OpenXRCompiler_exports));
-        return new OpenXRCompiler2(opts);
-      },
-      outputExtensions: [".cpp", ".h"]
-    },
-    {
-      name: "vrchat",
-      domain: "social-vr",
-      description: "Compiles to VRChat UdonSharp scripts",
-      supportedTraits: [
-        "physics",
-        "collidable",
-        "grabbable",
-        "audio",
-        "animation",
-        "networked",
-        "ui",
-        "interaction"
-      ],
-      riskTier: "standard",
-      factory: (opts) => {
-        const { VRChatCompiler: VRChatCompiler2 } = (init_VRChatCompiler(), __toCommonJS(VRChatCompiler_exports));
-        return new VRChatCompiler2(opts);
-      },
-      outputExtensions: [".cs"]
-    },
-    {
-      name: "visionos",
-      domain: "xr",
-      description: "Compiles to visionOS RealityKit Swift",
-      supportedTraits: [
-        "physics",
-        "hand_tracking",
-        "spatial_anchor",
-        "animation",
-        "material",
-        "collidable"
-      ],
-      riskTier: "standard",
-      factory: (opts) => {
-        const { VisionOSCompiler: VisionOSCompiler2 } = (init_VisionOSCompiler(), __toCommonJS(VisionOSCompiler_exports));
-        return new VisionOSCompiler2(opts);
-      },
-      outputExtensions: [".swift"]
-    },
-    {
-      name: "android-xr",
-      domain: "xr",
-      description: "Compiles to Android XR OpenXR Kotlin",
-      supportedTraits: ["physics", "hand_tracking", "spatial_anchor", "input", "collidable"],
-      riskTier: "standard",
-      factory: (opts) => {
-        const { AndroidXRCompiler: AndroidXRCompiler2 } = (init_AndroidXRCompiler(), __toCommonJS(AndroidXRCompiler_exports));
-        return new AndroidXRCompiler2(opts);
-      },
-      outputExtensions: [".kt"]
-    },
-    // ── Mobile ────────────────────────────────────────────────────────────
-    {
-      name: "ios",
-      domain: "mobile",
-      description: "Compiles to iOS ARKit Swift",
-      supportedTraits: ["physics", "ar_anchor", "animation", "material", "collidable"],
-      riskTier: "standard",
-      factory: (opts) => {
-        const { IOSCompiler: IOSCompiler2 } = (init_IOSCompiler(), __toCommonJS(IOSCompiler_exports));
-        return new IOSCompiler2(opts);
-      },
-      outputExtensions: [".swift"]
-    },
-    {
-      name: "android",
-      domain: "mobile",
-      description: "Compiles to Android ARCore Kotlin",
-      supportedTraits: ["physics", "ar_anchor", "animation", "material", "collidable"],
-      riskTier: "standard",
-      factory: (opts) => {
-        const { AndroidCompiler: AndroidCompiler2 } = (init_AndroidCompiler(), __toCommonJS(AndroidCompiler_exports));
-        return new AndroidCompiler2(opts);
-      },
-      outputExtensions: [".kt"]
-    },
-    {
-      name: "ar",
-      domain: "mobile",
-      description: "Compiles to generic AR platform code",
-      supportedTraits: ["physics", "ar_anchor", "spatial_anchor", "collidable", "material"],
-      riskTier: "standard",
-      factory: (opts) => {
-        const { ARCompiler: ARCompiler2 } = (init_ARCompiler(), __toCommonJS(ARCompiler_exports));
-        return new ARCompiler2(opts);
-      },
-      outputExtensions: [".ts"]
-    },
-    // ── Low-level ─────────────────────────────────────────────────────────
-    {
-      name: "wasm",
-      domain: "runtime",
-      description: "Compiles to WebAssembly modules",
-      supportedTraits: ["physics", "animation", "audio"],
-      riskTier: "high",
-      factory: (opts) => {
-        const { WASMCompiler: WASMCompiler2 } = (init_WASMCompiler(), __toCommonJS(WASMCompiler_exports));
-        return new WASMCompiler2(opts);
-      },
-      outputExtensions: [".wasm", ".js"]
-    },
-    {
-      name: "webgpu",
-      domain: "shader",
-      description: "Compiles to WebGPU compute shaders (WGSL)",
-      supportedTraits: ["physics", "particles", "fluid", "material", "compute"],
-      riskTier: "standard",
-      factory: (opts) => {
-        const { WebGPUCompiler: WebGPUCompiler2 } = (init_WebGPUCompiler(), __toCommonJS(WebGPUCompiler_exports));
-        return new WebGPUCompiler2(opts);
-      },
-      outputExtensions: [".wgsl", ".ts"]
-    },
-    // ── Robotics & IoT ───────────────────────────────────────────────────
-    {
-      name: "urdf",
-      domain: "robotics",
-      description: "Compiles to URDF robot descriptions",
-      supportedTraits: ["joint", "actuator", "sensor", "collider", "end_effector"],
-      riskTier: "standard",
-      factory: (opts) => {
-        const { URDFCompiler: URDFCompiler2 } = (init_URDFCompiler(), __toCommonJS(URDFCompiler_exports));
-        return new URDFCompiler2(opts);
-      },
-      outputExtensions: [".urdf"]
-    },
-    {
-      name: "sdf",
-      domain: "robotics",
-      description: "Compiles to SDF simulation descriptions (Gazebo)",
-      supportedTraits: ["joint", "actuator", "sensor", "collider", "physics", "environment"],
-      riskTier: "standard",
-      factory: (opts) => {
-        const { SDFCompiler: SDFCompiler2 } = (init_SDFCompiler(), __toCommonJS(SDFCompiler_exports));
-        return new SDFCompiler2(opts);
-      },
-      outputExtensions: [".sdf"]
-    },
-    {
-      name: "dtdl",
-      domain: "iot",
-      description: "Compiles to DTDL digital twin definitions",
-      supportedTraits: ["sensor", "telemetry", "property", "command", "relationship"],
-      riskTier: "standard",
-      factory: (opts) => {
-        const { DTDLCompiler: DTDLCompiler2 } = (init_DTDLCompiler(), __toCommonJS(DTDLCompiler_exports));
-        return new DTDLCompiler2(opts);
-      },
-      outputExtensions: [".json"]
-    },
-    // ── Specialized ───────────────────────────────────────────────────────
-    {
-      name: "state",
-      domain: "meta",
-      description: "Extracts reactive state descriptors from compositions",
-      supportedTraits: ["state", "bind", "reactive"],
-      riskTier: "standard",
-      factory: (opts) => {
-        const { StateCompiler: StateCompiler2 } = (init_StateCompiler(), __toCommonJS(StateCompiler_exports));
-        return new StateCompiler2(opts);
-      },
-      outputExtensions: [".json"]
-    },
-    {
-      name: "a2a-agent-card",
-      domain: "ai",
-      description: "Generates A2A Agent Card from composition metadata",
-      supportedTraits: ["agent", "skill", "capability"],
-      riskTier: "standard",
-      factory: (opts) => {
-        const { A2AAgentCardCompiler } = (init_A2AAgentCardCompiler(), __toCommonJS(A2AAgentCardCompiler_exports));
-        return new A2AAgentCardCompiler(opts);
-      },
-      outputExtensions: [".json"]
-    },
-    {
-      name: "nir",
-      domain: "neuromorphic",
-      description: "Compiles to Neuromorphic Intermediate Representation",
-      supportedTraits: ["snn", "neuron", "synapse", "spike_train"],
-      riskTier: "high",
-      factory: (opts) => {
-        const { NIRCompiler } = (init_NIRCompiler(), __toCommonJS(NIRCompiler_exports));
-        return new NIRCompiler(opts);
-      },
-      outputExtensions: [".json"]
-    },
-    {
-      name: "vrr",
-      domain: "xr",
-      description: "Compiles with Variable Rate Rendering optimizations",
-      supportedTraits: ["physics", "material", "lod", "rendering"],
-      riskTier: "standard",
-      factory: (opts) => {
-        const { VRRCompiler } = (init_VRRCompiler(), __toCommonJS(VRRCompiler_exports));
-        return new VRRCompiler(opts);
-      },
-      outputExtensions: [".ts"]
-    },
-    {
-      name: "native-2d",
-      domain: "web3d",
-      description: "Compiles to native 2D HTML/CSS/Canvas applications",
-      supportedTraits: ["layout", "style", "animation", "interaction"],
-      riskTier: "standard",
-      factory: (opts) => {
-        const { Native2DCompiler: Native2DCompiler2 } = (init_Native2DCompiler(), __toCommonJS(Native2DCompiler_exports));
-        return new Native2DCompiler2(opts);
-      },
-      outputExtensions: [".tsx", ".html"]
-    },
-    // ── Next.js API Routes ────────────────────────────────────────────────
-    {
-      name: "nextjs-api",
-      domain: "web",
-      description: "Compiles @http traits to Next.js App Router API route handlers (route.ts)",
-      supportedTraits: ["http", "handler", "middleware", "auth", "rate_limit", "cors"],
-      riskTier: "standard",
-      factory: () => {
-        const { compileToNextJSAPI: compileToNextJSAPI2 } = (init_NextJSAPICompiler(), __toCommonJS(NextJSAPICompiler_exports));
-        return {
-          compile: (composition, _token) => compileToNextJSAPI2(composition)
-        };
-      },
-      outputExtensions: [".ts"],
-      experimental: true
-    },
-    // ── v6 Universal Service ──────────────────────────────────────────────
-    {
-      name: "node-service",
-      domain: "service",
-      description: "Compiles @service traits to Express/Fastify applications",
-      supportedTraits: [
-        "service",
-        "endpoint",
-        "route",
-        "handler",
-        "middleware",
-        "cors_policy",
-        "rate_limiter",
-        "health_endpoint"
-      ],
-      riskTier: "standard",
-      factory: (opts) => {
-        const { NodeServiceCompiler: NodeServiceCompiler2 } = (init_NodeServiceCompiler(), __toCommonJS(NodeServiceCompiler_exports));
-        return new NodeServiceCompiler2(opts);
-      },
-      outputExtensions: [".ts", ".js"],
-      experimental: true
-    }
-  ];
-  for (const desc of descriptors) {
-    if (!DialectRegistry.has(desc.name)) {
-      DialectRegistry.register(desc);
-    }
-  }
-}
-var _registered;
-var init_registerBuiltinDialects = __esm({
-  "src/compiler/registerBuiltinDialects.ts"() {
-    init_DialectRegistry();
-    _registered = false;
-  }
-});
-
-// src/compiler/DialectRegistry.ts
-function ensureDialectsBooted() {
-  if (_autoBooted) return;
-  _autoBooted = true;
-  try {
-    const { registerBuiltinDialects: registerBuiltinDialects2 } = (init_registerBuiltinDialects(), __toCommonJS(registerBuiltinDialects_exports));
-    registerBuiltinDialects2();
-  } catch {
-  }
-}
-var DialectRegistryImpl, DialectRegistry, _autoBooted;
-var init_DialectRegistry = __esm({
-  "src/compiler/DialectRegistry.ts"() {
-    DialectRegistryImpl = class {
-      constructor() {
-        this.dialects = /* @__PURE__ */ new Map();
-      }
-      /**
-       * Register a new compiler dialect.
-       * @throws Error if a dialect with the same name already exists
-       */
-      register(descriptor) {
-        if (this.dialects.has(descriptor.name)) {
-          throw new Error(
-            `Dialect "${descriptor.name}" is already registered. Use DialectRegistry.override() to replace an existing dialect.`
-          );
-        }
-        if (!descriptor.ansPath) {
-          descriptor.ansPath = `/compile/${descriptor.domain}/${descriptor.name}`;
-        }
-        this.dialects.set(descriptor.name, descriptor);
-      }
-      /**
-       * Override an existing dialect registration.
-       */
-      override(descriptor) {
-        if (!descriptor.ansPath) {
-          descriptor.ansPath = `/compile/${descriptor.domain}/${descriptor.name}`;
-        }
-        this.dialects.set(descriptor.name, descriptor);
-      }
-      /**
-       * Unregister a dialect.
-       */
-      unregister(name) {
-        return this.dialects.delete(name);
-      }
-      /**
-       * Check if a dialect is registered.
-       */
-      has(name) {
-        return this.dialects.has(name);
-      }
-      /**
-       * Get dialect info (without factory, safe for discovery).
-       */
-      get(name) {
-        const desc = this.dialects.get(name);
-        if (!desc) return void 0;
-        return {
-          name: desc.name,
-          domain: desc.domain,
-          description: desc.description,
-          supportedTraits: desc.supportedTraits,
-          riskTier: desc.riskTier,
-          ansPath: desc.ansPath || `/compile/${desc.domain}/${desc.name}`,
-          outputExtensions: desc.outputExtensions || [],
-          experimental: desc.experimental ?? false
-        };
-      }
-      /**
-       * Create a compiler instance from a registered dialect.
-       * @throws Error if dialect not found
-       */
-      create(name, options) {
-        const desc = this.dialects.get(name);
-        if (!desc) {
-          const available = [...this.dialects.keys()].join(", ");
-          throw new Error(`Unknown dialect "${name}". Available: ${available}`);
-        }
-        return desc.factory(options);
-      }
-      /**
-       * List all registered dialects.
-       */
-      list() {
-        return [...this.dialects.values()].map((desc) => ({
-          name: desc.name,
-          domain: desc.domain,
-          description: desc.description,
-          supportedTraits: desc.supportedTraits,
-          riskTier: desc.riskTier,
-          ansPath: desc.ansPath || `/compile/${desc.domain}/${desc.name}`,
-          outputExtensions: desc.outputExtensions || [],
-          experimental: desc.experimental ?? false
-        }));
-      }
-      /**
-       * List dialects filtered by domain.
-       */
-      listByDomain(domain) {
-        return this.list().filter((d) => d.domain === domain);
-      }
-      /**
-       * Find dialects that support a specific trait.
-       */
-      findByTrait(traitName) {
-        return this.list().filter((d) => d.supportedTraits.includes(traitName));
-      }
-      /**
-       * Get all registered dialect names.
-       */
-      names() {
-        return [...this.dialects.keys()];
-      }
-      /**
-       * Get count of registered dialects.
-       */
-      get size() {
-        return this.dialects.size;
-      }
-      /**
-       * Execute a progressive lowering pipeline for a dialect.
-       * Runs all registered lowering passes in priority order.
-       */
-      executeLoweringPipeline(dialectName, composition, options = {}) {
-        const desc = this.dialects.get(dialectName);
-        if (!desc) {
-          throw new Error(`Unknown dialect "${dialectName}"`);
-        }
-        const passes = [...desc.loweringPasses || []].sort((a, b) => a.priority - b.priority);
-        if (passes.length === 0) {
-          throw new Error(
-            `Dialect "${dialectName}" has no lowering passes. Use create() for direct compilation.`
-          );
-        }
-        const context = {
-          target: dialectName,
-          options,
-          previousPasses: /* @__PURE__ */ new Map(),
-          diagnostics: []
-        };
-        let lastResult = { output: "" };
-        for (const pass of passes) {
-          lastResult = pass.lower(composition, context);
-          context.previousPasses.set(pass.name, lastResult);
-          if (lastResult.diagnostics) {
-            context.diagnostics.push(...lastResult.diagnostics);
-          }
-          const hasError = lastResult.diagnostics?.some((d) => d.level === "error");
-          if (hasError) break;
-        }
-        lastResult.diagnostics = context.diagnostics;
-        return lastResult;
-      }
-    };
-    DialectRegistry = new DialectRegistryImpl();
-    _autoBooted = false;
-  }
-});
-
-// src/compiler/NodeServiceCompiler.ts
-var NodeServiceCompiler_exports = {};
-__export(NodeServiceCompiler_exports, {
-  NodeServiceCompiler: () => NodeServiceCompiler
-});
-var NodeServiceCompiler;
-var init_NodeServiceCompiler = __esm({
-  "src/compiler/NodeServiceCompiler.ts"() {
-    init_CompilerBase();
-    init_ANSNamespace();
-    init_DialectRegistry();
-    NodeServiceCompiler = class extends CompilerBase {
-      constructor(options = {}) {
-        super();
-        this.compilerName = "NodeServiceCompiler";
-        this.services = [];
-        this.options = {
-          framework: options.framework ?? "express",
-          port: options.port ?? 3e3,
-          apiPrefix: options.apiPrefix ?? "/api",
-          typescript: options.typescript ?? true,
-          nodeVersion: options.nodeVersion ?? "20",
-          includeDocker: options.includeDocker ?? false
+var NodeServiceCompiler;
+var init_NodeServiceCompiler = __esm({
+  "src/compiler/NodeServiceCompiler.ts"() {
+    init_CompilerBase();
+    init_identity();
+    init_DialectRegistry();
+    init_constants();
+    NodeServiceCompiler = class extends CompilerBase {
+      constructor(options = {}) {
+        super();
+        this.compilerName = "NodeServiceCompiler";
+        this.services = [];
+        this.options = {
+          framework: options.framework ?? "express",
+          port: options.port ?? 3e3,
+          apiPrefix: options.apiPrefix ?? "/api",
+          typescript: options.typescript ?? true,
+          nodeVersion: options.nodeVersion ?? "20",
+          includeDocker: options.includeDocker ?? false
         };
       }
       getRequiredCapability() {
         return ANSCapabilityPath.NODE_SERVICE;
       }
       compile(composition, agentToken, outputPath) {
+        console.log("DEBUG: Composition:", JSON.stringify(composition, null, 2));
         this.validateCompilerAccess(agentToken, outputPath);
         this.services = [];
         this.extractServices(composition);
@@ -856,6 +766,18 @@ var init_NodeServiceCompiler = __esm({
         if (allMiddleware.length > 0) {
           output[this.ext("middleware/index")] = this.emitMiddlewareIndex(allMiddleware);
         }
+        const allEnvVars = this.collectEnvVars();
+        if (allEnvVars.length > 0) {
+          output[this.ext("config/env")] = this.emitEnvConfig(allEnvVars);
+        }
+        const allConnectors = this.collectConnectors();
+        if (allConnectors.length > 0) {
+          output[this.ext("connectors/index")] = this.emitConnectorsIndex(allConnectors);
+        }
+        const railwayService = this.services.find((s) => s.deploy?.platform === "railway");
+        if (railwayService?.deploy) {
+          output["railway.json"] = this.emitRailwayConfig(railwayService.deploy);
+        }
         output["package.json"] = this.emitPackageJson(composition.name);
         if (this.options.typescript) {
           output["tsconfig.json"] = this.emitTsConfig();
@@ -863,6 +785,7 @@ var init_NodeServiceCompiler = __esm({
         if (this.options.includeDocker) {
           output["Dockerfile"] = this.emitDockerfile();
         }
+        this.validateConnectorIntegration();
         return output;
       }
       // ── Extraction ─────────────────────────────────────────────────────────
@@ -874,9 +797,11 @@ var init_NodeServiceCompiler = __esm({
             }
           }
         }
-        for (const obj of composition.objects) {
-          if (this.hasServiceTraits(obj)) {
-            this.services.push(this.parseServiceObject(obj));
+        if (composition.objects) {
+          for (const obj of composition.objects) {
+            if (this.hasServiceTraits(obj)) {
+              this.services.push(this.parseServiceObject(obj));
+            }
           }
         }
         if (this.services.length === 0) {
@@ -884,6 +809,8 @@ var init_NodeServiceCompiler = __esm({
             name: composition.name || "App",
             routes: [],
             middleware: [],
+            connectors: [],
+            envVars: [],
             port: this.options.port
           });
         }
@@ -893,7 +820,7 @@ var init_NodeServiceCompiler = __esm({
       }
       hasServiceTraits(obj) {
         if (!obj.traits) return false;
-        const serviceTraits = ["service", "endpoint", "http", "handler", "route"];
+        const serviceTraits = ["service", "endpoint", "http", "handler", "route", "connector", "env", "deploy"];
         return obj.traits.some((t) => serviceTraits.includes(t.name));
       }
       parseServiceBlock(block) {
@@ -901,10 +828,15 @@ var init_NodeServiceCompiler = __esm({
           name: block.name,
           routes: [],
           middleware: [],
-          port: this.resolveNumber(block.properties["port"]) ?? this.options.port
+          port: this.resolveNumber(block.properties["port"]) ?? this.options.port,
+          connectors: [],
+          envVars: []
         };
         if (block.traits) {
           service.middleware = this.extractMiddlewareFromTraits(block.traits);
+          service.connectors = this.extractConnectors(block.traits, block.properties);
+          service.envVars = this.extractEnvVars(block.traits, block.properties);
+          service.deploy = this.extractDeploy(block.traits, block.properties);
         }
         if (block.children) {
           for (const child of block.children) {
@@ -921,10 +853,16 @@ var init_NodeServiceCompiler = __esm({
           name: obj.name,
           routes: [],
           middleware: [],
-          port: this.options.port
+          port: this.options.port,
+          connectors: [],
+          envVars: []
         };
         if (obj.traits) {
-          service.middleware = this.extractMiddlewareFromTraits(obj.traits.map((t) => t.name));
+          const traitNames = obj.traits.map((t) => t.name);
+          service.middleware = this.extractMiddlewareFromTraits(traitNames);
+          service.connectors = this.extractConnectors(traitNames, this.objectPropsToMap(obj.properties));
+          service.envVars = this.extractEnvVars(traitNames, this.objectPropsToMap(obj.properties));
+          service.deploy = this.extractDeploy(traitNames, this.objectPropsToMap(obj.properties));
         }
         const route = this.extractRoute(obj, obj.name);
         if (route) service.routes.push(route);
@@ -976,6 +914,56 @@ var init_NodeServiceCompiler = __esm({
         }
         return [...set];
       }
+      // ── Connector Extraction ──────────────────────────────────────────────
+      extractConnectors(traits, props) {
+        const connectors = [];
+        const propMap = props instanceof Map ? props : this.objectPropsToMapFromRecord(props);
+        for (const t of traits) {
+          if (t === "connector" || t === "@connector") {
+            const name = this.resolveString(propMap.get("connector_name")) || "unknown";
+            connectors.push({ name, config: {} });
+          }
+        }
+        return connectors;
+      }
+      extractEnvVars(traits, props) {
+        const envVars = [];
+        const propMap = props instanceof Map ? props : this.objectPropsToMapFromRecord(props);
+        for (const t of traits) {
+          if (t === "env" || t === "@env") {
+            const name = this.resolveString(propMap.get("env_name")) || "UNKNOWN_VAR";
+            envVars.push({
+              name,
+              required: this.resolveBoolean(propMap.get("env_required")) ?? true,
+              defaultValue: this.resolveString(propMap.get("env_default"))
+            });
+          }
+        }
+        return envVars;
+      }
+      extractDeploy(traits, props) {
+        if (!traits.some((t) => t === "deploy" || t === "@deploy")) return void 0;
+        const propMap = props instanceof Map ? props : this.objectPropsToMapFromRecord(props);
+        return {
+          platform: this.resolveString(propMap.get("platform")) || "railway",
+          service: this.resolveString(propMap.get("service")),
+          environment: this.resolveString(propMap.get("environment")),
+          healthPath: this.resolveString(propMap.get("healthPath")) || "/health"
+        };
+      }
+      objectPropsToMapFromRecord(props) {
+        const map = /* @__PURE__ */ new Map();
+        for (const [k, v] of Object.entries(props)) {
+          map.set(k, v);
+        }
+        return map;
+      }
+      resolveBoolean(val) {
+        if (val === void 0 || val === null) return void 0;
+        if (typeof val === "boolean") return val;
+        if (typeof val === "string") return val === "true";
+        return void 0;
+      }
       // ── Code Emission ──────────────────────────────────────────────────────
       emitEntryPoint() {
         const isExpress = this.options.framework === "express";
@@ -987,6 +975,11 @@ var init_NodeServiceCompiler = __esm({
         lines.push("");
         if (isExpress) {
           lines.push(`import express from 'express';`);
+          lines.push(`import './config/env';`);
+          const hasConnectors = this.collectConnectors().length > 0;
+          if (hasConnectors) {
+            lines.push(`import { initConnectors } from './connectors';`);
+          }
           for (const service of this.services) {
             const importName = `${this.toCamelCase(service.name)}Routes`;
             lines.push(`import { ${importName} } from './routes/${this.toFileName(service.name)}';`);
@@ -1004,9 +997,17 @@ var init_NodeServiceCompiler = __esm({
           }
           lines.push("");
           lines.push(`const PORT = process.env['PORT'] || ${this.options.port};`);
-          lines.push(`app.listen(PORT, () => {`);
-          lines.push(`  console.log(\`Server running on port \${PORT}\`);`);
-          lines.push(`});`);
+          if (hasConnectors) {
+            lines.push(`initConnectors().then(() => {`);
+            lines.push(`  app.listen(PORT, () => {`);
+            lines.push(`    console.log(\`Server running on port \${PORT}\`);`);
+            lines.push(`  });`);
+            lines.push(`});`);
+          } else {
+            lines.push(`app.listen(PORT, () => {`);
+            lines.push(`  console.log(\`Server running on port \${PORT}\`);`);
+            lines.push(`});`);
+          }
           lines.push("");
           lines.push(`export { app };`);
         } else {
@@ -1115,177 +1116,920 @@ var init_NodeServiceCompiler = __esm({
         }
         return lines.join("\n");
       }
-      emitMiddlewareIndex(middleware) {
-        const lines = [];
-        lines.push(`/**`);
-        lines.push(` * Middleware stubs`);
-        lines.push(` * Auto-generated by HoloScript NodeServiceCompiler`);
-        lines.push(` */`);
-        lines.push("");
-        if (this.options.framework === "express") {
-          lines.push(`import type { Request, Response, NextFunction } from 'express';`);
-          lines.push("");
-          for (const mw of middleware) {
-            const fnName = this.toCamelCase(mw) + "Middleware";
-            lines.push(`export function ${fnName}(req: Request, _res: Response, next: NextFunction) {`);
-            lines.push(`  // TODO: Implement ${mw} middleware`);
-            lines.push(`  next();`);
-            lines.push(`}`);
-            lines.push("");
-          }
-        } else {
-          lines.push(
-            `import type { FastifyRequest, FastifyReply, HookHandlerDoneFunction } from 'fastify';`
+      emitMiddlewareIndex(middleware) {
+        const lines = [];
+        lines.push(`/**`);
+        lines.push(` * Middleware stubs`);
+        lines.push(` * Auto-generated by HoloScript NodeServiceCompiler`);
+        lines.push(` */`);
+        lines.push("");
+        if (this.options.framework === "express") {
+          lines.push(`import type { Request, Response, NextFunction } from 'express';`);
+          lines.push("");
+          for (const mw of middleware) {
+            const fnName = this.toCamelCase(mw) + "Middleware";
+            lines.push(`export function ${fnName}(req: Request, _res: Response, next: NextFunction) {`);
+            lines.push(`  // TODO: Implement ${mw} middleware`);
+            lines.push(`  next();`);
+            lines.push(`}`);
+            lines.push("");
+          }
+        } else {
+          lines.push(
+            `import type { FastifyRequest, FastifyReply, HookHandlerDoneFunction } from 'fastify';`
+          );
+          lines.push("");
+          for (const mw of middleware) {
+            const fnName = this.toCamelCase(mw) + "Middleware";
+            lines.push(
+              `export function ${fnName}(request: FastifyRequest, _reply: FastifyReply, done: HookHandlerDoneFunction) {`
+            );
+            lines.push(`  // TODO: Implement ${mw} middleware`);
+            lines.push(`  done();`);
+            lines.push(`}`);
+            lines.push("");
+          }
+        }
+        return lines.join("\n");
+      }
+      emitPackageJson(projectName) {
+        const name = this.toKebab(projectName || "holoscript-service");
+        const isExpress = this.options.framework === "express";
+        const dependencies = isExpress ? { express: "^4.21.0", dotenv: "^16.4.0" } : { fastify: "^5.0.0", dotenv: "^16.4.0" };
+        const connectors = this.collectConnectors();
+        for (const conn of connectors) {
+          const pkg2 = CONNECTOR_PACKAGES[conn.name];
+          if (pkg2) {
+            dependencies[pkg2] = "latest";
+          }
+        }
+        const pkg = {
+          name,
+          version: "0.1.0",
+          description: `Generated by HoloScript NodeServiceCompiler`,
+          main: this.options.typescript ? "dist/index.js" : "index.js",
+          scripts: {
+            ...this.options.typescript ? {
+              build: "tsc",
+              start: "node dist/index.js",
+              dev: "tsx watch index.ts"
+            } : {
+              start: "node index.js",
+              dev: "node --watch index.js"
+            }
+          },
+          dependencies,
+          ...this.options.typescript && {
+            devDependencies: {
+              typescript: "^5.5.0",
+              tsx: "^4.0.0",
+              ...isExpress ? { "@types/express": "^4.17.21", "@types/node": "^20.0.0" } : { "@types/node": "^20.0.0" }
+            }
+          }
+        };
+        return JSON.stringify(pkg, null, 2);
+      }
+      emitTsConfig() {
+        const config = {
+          compilerOptions: {
+            target: "ES2022",
+            module: "NodeNext",
+            moduleResolution: "NodeNext",
+            outDir: "./dist",
+            rootDir: "./",
+            strict: true,
+            esModuleInterop: true,
+            skipLibCheck: true,
+            declaration: true
+          },
+          include: ["./**/*.ts"],
+          exclude: ["node_modules", "dist"]
+        };
+        return JSON.stringify(config, null, 2);
+      }
+      emitDockerfile() {
+        const nodeVer = this.options.nodeVersion;
+        return [
+          `FROM node:${nodeVer}-alpine AS builder`,
+          `WORKDIR /app`,
+          `COPY package*.json ./`,
+          `RUN npm ci`,
+          `COPY . .`,
+          ...this.options.typescript ? [`RUN npm run build`] : [],
+          ``,
+          `FROM node:${nodeVer}-alpine`,
+          `WORKDIR /app`,
+          `COPY --from=builder /app/package*.json ./`,
+          `RUN npm ci --omit=dev`,
+          ...this.options.typescript ? [`COPY --from=builder /app/dist ./dist`] : [`COPY --from=builder /app/*.js ./`],
+          `EXPOSE ${this.options.port}`,
+          `CMD ["npm", "start"]`,
+          ``
+        ].join("\n");
+      }
+      // ── Utilities ──────────────────────────────────────────────────────────
+      collectEnvVars() {
+        const map = /* @__PURE__ */ new Map();
+        for (const service of this.services) {
+          for (const env of service.envVars) {
+            map.set(env.name, env);
+          }
+          for (const conn of service.connectors) {
+            const requirements = CONNECTOR_ENV_REQUIREMENTS[conn.name] || [];
+            for (const req of requirements) {
+              if (!map.has(req)) {
+                map.set(req, { name: req, required: true });
+              }
+            }
+          }
+        }
+        return Array.from(map.values());
+      }
+      collectConnectors() {
+        const map = /* @__PURE__ */ new Map();
+        for (const service of this.services) {
+          for (const conn of service.connectors) {
+            map.set(conn.name, conn);
+          }
+        }
+        return Array.from(map.values());
+      }
+      // ── Emitters ──────────────────────────────────────────────────────────
+      emitEnvConfig(envVars) {
+        const lines = [];
+        lines.push(`/**`);
+        lines.push(` * Environment Configuration`);
+        lines.push(` * Auto-generated by HoloScript NodeServiceCompiler`);
+        lines.push(` */`);
+        lines.push(``);
+        lines.push(`import dotenv from 'dotenv';`);
+        lines.push(`dotenv.config();`);
+        lines.push(``);
+        lines.push(`export const env = {`);
+        for (const ev of envVars) {
+          const fallback = ev.defaultValue ? ` || '${ev.defaultValue}'` : "";
+          lines.push(`  ${ev.name}: process.env['${ev.name}']${fallback},`);
+        }
+        lines.push(`};`);
+        lines.push(``);
+        lines.push(`// Validation`);
+        lines.push(`const missing: string[] = [];`);
+        for (const ev of envVars) {
+          if (ev.required) {
+            lines.push(`if (!env.${ev.name}) missing.push('${ev.name}');`);
+          }
+        }
+        lines.push(``);
+        lines.push(`if (missing.length > 0) {`);
+        lines.push(`  console.error('Missing required environment variables:', missing.join(', '));`);
+        lines.push(`  process.exit(1);`);
+        lines.push(`}`);
+        return lines.join("\n");
+      }
+      emitConnectorsIndex(connectors) {
+        const lines = [];
+        lines.push(`/**`);
+        lines.push(` * Connector Registry`);
+        lines.push(` * Auto-generated by HoloScript NodeServiceCompiler`);
+        lines.push(` */`);
+        lines.push(``);
+        for (const conn of connectors) {
+          const pkg = CONNECTOR_PACKAGES[conn.name];
+          if (pkg) {
+            lines.push(`import { ${this.toClassName(conn.name)}Connector } from '${pkg}';`);
+          }
+        }
+        lines.push(``);
+        for (const conn of connectors) {
+          const className = this.toClassName(conn.name);
+          lines.push(`export const ${conn.name} = new ${className}Connector();`);
+        }
+        lines.push(``);
+        lines.push(`export async function initConnectors(): Promise<void> {`);
+        lines.push(`  await Promise.all([`);
+        for (const conn of connectors) {
+          lines.push(`    ${conn.name}.connect(),`);
+        }
+        lines.push(`  ]);`);
+        for (const conn of connectors) {
+          lines.push(`  console.log('[connectors] ${conn.name}: connected');`);
+        }
+        lines.push(`}`);
+        lines.push(``);
+        lines.push(`export async function shutdownConnectors(): Promise<void> {`);
+        lines.push(`  await Promise.all([`);
+        for (const conn of connectors) {
+          lines.push(`    ${conn.name}.disconnect(),`);
+        }
+        lines.push(`  ]);`);
+        lines.push(`}`);
+        return lines.join("\n");
+      }
+      emitRailwayConfig(deploy) {
+        const config = {
+          $schema: "https://railway.app/railway.schema.json",
+          build: {
+            builder: "DOCKERFILE",
+            dockerfilePath: "Dockerfile"
+          },
+          deploy: {
+            numReplicas: 1,
+            sleepApplication: false,
+            restartPolicyType: "ON_FAILURE",
+            healthcheckPath: deploy.healthPath || "/health"
+          }
+        };
+        return JSON.stringify(config, null, 2);
+      }
+      toClassName(name) {
+        return name.charAt(0).toUpperCase() + this.toCamelCase(name).slice(1);
+      }
+      /** Convert HoloObjectProperty[] to a Map for key-based lookup */
+      objectPropsToMap(props) {
+        const map = /* @__PURE__ */ new Map();
+        if (!props) return map;
+        for (const prop of props) {
+          map.set(prop.key, prop.value);
+        }
+        return map;
+      }
+      ext(name) {
+        return this.options.typescript ? `${name}.ts` : `${name}.js`;
+      }
+      toFileName(name) {
+        return name.replace(/[^a-zA-Z0-9]/g, "-").replace(/-+/g, "-");
+      }
+      toKebab(name) {
+        return name.replace(/([a-z])([A-Z])/g, "$1-$2").replace(/[^a-zA-Z0-9]/g, "-").replace(/-+/g, "-").toLowerCase();
+      }
+      toCamelCase(name) {
+        const parts = name.replace(/[^a-zA-Z0-9]/g, " ").split(/\s+/).filter(Boolean);
+        if (parts.length === 0) return "unnamed";
+        return parts[0].toLowerCase() + parts.slice(1).map((p) => p.charAt(0).toUpperCase() + p.slice(1).toLowerCase()).join("");
+      }
+      resolveString(val) {
+        if (val === void 0 || val === null) return void 0;
+        if (typeof val === "string") return val;
+        if (typeof val === "object" && "value" in val) return String(val.value);
+        return String(val);
+      }
+      resolveNumber(val) {
+        if (val === void 0 || val === null) return void 0;
+        if (typeof val === "number") return val;
+        if (typeof val === "string") {
+          const n = Number(val);
+          return isNaN(n) ? void 0 : n;
+        }
+        if (typeof val === "object" && "value" in val) {
+          const n = Number(val.value);
+          return isNaN(n) ? void 0 : n;
+        }
+        return void 0;
+      }
+      validateConnectorIntegration() {
+        const connectors = this.collectConnectors();
+        const envVars = this.collectEnvVars();
+        const envMap = new Map(envVars.map((ev) => [ev.name, ev]));
+        for (const conn of connectors) {
+          if (!KNOWN_CONNECTORS.includes(conn.name)) {
+            console.warn(`[NodeServiceCompiler] Warning: Unknown connector '${conn.name}'. Package dependency will not be added.`);
+          } else {
+            const requirements = CONNECTOR_ENV_REQUIREMENTS[conn.name] || [];
+            for (const req of requirements) {
+              if (!envMap.has(req)) {
+                throw new Error(`Connector '${conn.name}' requires environment variable '${req}'`);
+              }
+            }
+          }
+        }
+        const deployable = this.services.find((s) => s.deploy);
+        if (deployable?.deploy) {
+          if (deployable.deploy.platform !== "railway") {
+            console.warn(
+              `[NodeServiceCompiler] Warning: Platform '${deployable.deploy.platform}' is not explicitly supported for config generation yet.`
+            );
+          }
+        }
+      }
+    };
+    DialectRegistry.register({
+      name: "node-service",
+      domain: "service",
+      description: "Compiles @service traits to Express/Fastify Node.js applications",
+      supportedTraits: [
+        "service",
+        "endpoint",
+        "route",
+        "handler",
+        "middleware",
+        "http",
+        "gateway",
+        "proxy",
+        "load_balancer",
+        "auth",
+        "cors",
+        "rate_limit",
+        "validation",
+        "connector",
+        "env",
+        "deploy",
+        "on_connector_event"
+      ],
+      riskTier: "standard",
+      factory: (options) => new NodeServiceCompiler(options),
+      outputExtensions: [".ts", ".js", ".json"],
+      experimental: true
+    });
+  }
+});
+
+// src/compiler/registerBuiltinDialects.ts
+var registerBuiltinDialects_exports = {};
+__export(registerBuiltinDialects_exports, {
+  registerBuiltinDialects: () => registerBuiltinDialects
+});
+function registerBuiltinDialects() {
+  if (_registered) return;
+  _registered = true;
+  const descriptors = [
+    // ── Game Engines ──────────────────────────────────────────────────────
+    {
+      name: "unity",
+      domain: "gamedev",
+      description: "Compiles to Unity C# MonoBehaviours",
+      supportedTraits: [
+        "physics",
+        "collidable",
+        "grabbable",
+        "throwable",
+        "audio",
+        "spatial_audio",
+        "animation",
+        "particles",
+        "material",
+        "ui",
+        "networked",
+        "behavior_tree",
+        "navmesh",
+        "lod"
+      ],
+      riskTier: "standard",
+      factory: (opts) => {
+        const { UnityCompiler: UnityCompiler2 } = (init_UnityCompiler(), __toCommonJS(UnityCompiler_exports));
+        return new UnityCompiler2(opts);
+      },
+      outputExtensions: [".cs"]
+    },
+    {
+      name: "unreal",
+      domain: "gamedev",
+      description: "Compiles to Unreal Engine C++ actors",
+      supportedTraits: [
+        "physics",
+        "collidable",
+        "grabbable",
+        "audio",
+        "animation",
+        "particles",
+        "material",
+        "niagara",
+        "landscape",
+        "behavior_tree",
+        "navmesh",
+        "lod"
+      ],
+      riskTier: "standard",
+      factory: (opts) => {
+        const { UnrealCompiler } = (init_UnrealCompiler(), __toCommonJS(UnrealCompiler_exports));
+        return new UnrealCompiler(opts);
+      },
+      outputExtensions: [".cpp", ".h"]
+    },
+    {
+      name: "godot",
+      domain: "gamedev",
+      description: "Compiles to Godot GDScript nodes",
+      supportedTraits: [
+        "physics",
+        "collidable",
+        "grabbable",
+        "audio",
+        "animation",
+        "particles",
+        "material",
+        "behavior_tree",
+        "navmesh"
+      ],
+      riskTier: "standard",
+      factory: (opts) => {
+        const { GodotCompiler: GodotCompiler2 } = (init_GodotCompiler(), __toCommonJS(GodotCompiler_exports));
+        return new GodotCompiler2(opts);
+      },
+      outputExtensions: [".gd", ".tscn"]
+    },
+    // ── Web 3D ────────────────────────────────────────────────────────────
+    {
+      name: "r3f",
+      domain: "web3d",
+      description: "Compiles to React Three Fiber JSX components",
+      supportedTraits: [
+        "physics",
+        "collidable",
+        "grabbable",
+        "audio",
+        "spatial_audio",
+        "animation",
+        "particles",
+        "material",
+        "ui",
+        "behavior_tree",
+        "lod",
+        "vr_only",
+        "ar_only"
+      ],
+      riskTier: "standard",
+      factory: (opts) => {
+        const { R3FCompiler: R3FCompiler2 } = (init_R3FCompiler(), __toCommonJS(R3FCompiler_exports));
+        return new R3FCompiler2(opts);
+      },
+      outputExtensions: [".tsx", ".jsx"]
+    },
+    {
+      name: "babylon",
+      domain: "web3d",
+      description: "Compiles to Babylon.js scene code",
+      supportedTraits: [
+        "physics",
+        "collidable",
+        "audio",
+        "animation",
+        "particles",
+        "material",
+        "behavior_tree"
+      ],
+      riskTier: "standard",
+      factory: (opts) => {
+        const { BabylonCompiler: BabylonCompiler2 } = (init_BabylonCompiler(), __toCommonJS(BabylonCompiler_exports));
+        return new BabylonCompiler2(opts);
+      },
+      outputExtensions: [".ts", ".js"]
+    },
+    {
+      name: "playcanvas",
+      domain: "web3d",
+      description: "Compiles to PlayCanvas engine scripts",
+      supportedTraits: ["physics", "collidable", "audio", "animation", "material"],
+      riskTier: "standard",
+      factory: (opts) => {
+        const { PlayCanvasCompiler: PlayCanvasCompiler2 } = (init_PlayCanvasCompiler(), __toCommonJS(PlayCanvasCompiler_exports));
+        return new PlayCanvasCompiler2(opts);
+      },
+      outputExtensions: [".js"]
+    },
+    // ── VR/XR ─────────────────────────────────────────────────────────────
+    {
+      name: "openxr",
+      domain: "xr",
+      description: "Compiles to OpenXR C++ application layer",
+      supportedTraits: [
+        "physics",
+        "hand_tracking",
+        "spatial_anchor",
+        "input",
+        "collidable",
+        "grabbable"
+      ],
+      riskTier: "standard",
+      factory: (opts) => {
+        const { OpenXRCompiler: OpenXRCompiler2 } = (init_OpenXRCompiler(), __toCommonJS(OpenXRCompiler_exports));
+        return new OpenXRCompiler2(opts);
+      },
+      outputExtensions: [".cpp", ".h"]
+    },
+    {
+      name: "vrchat",
+      domain: "social-vr",
+      description: "Compiles to VRChat UdonSharp scripts",
+      supportedTraits: [
+        "physics",
+        "collidable",
+        "grabbable",
+        "audio",
+        "animation",
+        "networked",
+        "ui",
+        "interaction"
+      ],
+      riskTier: "standard",
+      factory: (opts) => {
+        const { VRChatCompiler: VRChatCompiler2 } = (init_VRChatCompiler(), __toCommonJS(VRChatCompiler_exports));
+        return new VRChatCompiler2(opts);
+      },
+      outputExtensions: [".cs"]
+    },
+    {
+      name: "visionos",
+      domain: "xr",
+      description: "Compiles to visionOS RealityKit Swift",
+      supportedTraits: [
+        "physics",
+        "hand_tracking",
+        "spatial_anchor",
+        "animation",
+        "material",
+        "collidable"
+      ],
+      riskTier: "standard",
+      factory: (opts) => {
+        const { VisionOSCompiler: VisionOSCompiler2 } = (init_VisionOSCompiler(), __toCommonJS(VisionOSCompiler_exports));
+        return new VisionOSCompiler2(opts);
+      },
+      outputExtensions: [".swift"]
+    },
+    {
+      name: "android-xr",
+      domain: "xr",
+      description: "Compiles to Android XR OpenXR Kotlin",
+      supportedTraits: ["physics", "hand_tracking", "spatial_anchor", "input", "collidable"],
+      riskTier: "standard",
+      factory: (opts) => {
+        const { AndroidXRCompiler: AndroidXRCompiler2 } = (init_AndroidXRCompiler(), __toCommonJS(AndroidXRCompiler_exports));
+        return new AndroidXRCompiler2(opts);
+      },
+      outputExtensions: [".kt"]
+    },
+    // ── Mobile ────────────────────────────────────────────────────────────
+    {
+      name: "ios",
+      domain: "mobile",
+      description: "Compiles to iOS ARKit Swift",
+      supportedTraits: ["physics", "ar_anchor", "animation", "material", "collidable"],
+      riskTier: "standard",
+      factory: (opts) => {
+        const { IOSCompiler: IOSCompiler2 } = (init_IOSCompiler(), __toCommonJS(IOSCompiler_exports));
+        return new IOSCompiler2(opts);
+      },
+      outputExtensions: [".swift"]
+    },
+    {
+      name: "android",
+      domain: "mobile",
+      description: "Compiles to Android ARCore Kotlin",
+      supportedTraits: ["physics", "ar_anchor", "animation", "material", "collidable"],
+      riskTier: "standard",
+      factory: (opts) => {
+        const { AndroidCompiler: AndroidCompiler2 } = (init_AndroidCompiler(), __toCommonJS(AndroidCompiler_exports));
+        return new AndroidCompiler2(opts);
+      },
+      outputExtensions: [".kt"]
+    },
+    {
+      name: "ar",
+      domain: "mobile",
+      description: "Compiles to generic AR platform code",
+      supportedTraits: ["physics", "ar_anchor", "spatial_anchor", "collidable", "material"],
+      riskTier: "standard",
+      factory: (opts) => {
+        const { ARCompiler: ARCompiler2 } = (init_ARCompiler(), __toCommonJS(ARCompiler_exports));
+        return new ARCompiler2(opts);
+      },
+      outputExtensions: [".ts"]
+    },
+    // ── Low-level ─────────────────────────────────────────────────────────
+    {
+      name: "wasm",
+      domain: "runtime",
+      description: "Compiles to WebAssembly modules",
+      supportedTraits: ["physics", "animation", "audio"],
+      riskTier: "high",
+      factory: (opts) => {
+        const { WASMCompiler: WASMCompiler2 } = (init_WASMCompiler(), __toCommonJS(WASMCompiler_exports));
+        return new WASMCompiler2(opts);
+      },
+      outputExtensions: [".wasm", ".js"]
+    },
+    {
+      name: "webgpu",
+      domain: "shader",
+      description: "Compiles to WebGPU compute shaders (WGSL)",
+      supportedTraits: ["physics", "particles", "fluid", "material", "compute"],
+      riskTier: "standard",
+      factory: (opts) => {
+        const { WebGPUCompiler: WebGPUCompiler2 } = (init_WebGPUCompiler(), __toCommonJS(WebGPUCompiler_exports));
+        return new WebGPUCompiler2(opts);
+      },
+      outputExtensions: [".wgsl", ".ts"]
+    },
+    // ── Robotics & IoT ───────────────────────────────────────────────────
+    {
+      name: "urdf",
+      domain: "robotics",
+      description: "Compiles to URDF robot descriptions",
+      supportedTraits: ["joint", "actuator", "sensor", "collider", "end_effector"],
+      riskTier: "standard",
+      factory: (opts) => {
+        const { URDFCompiler: URDFCompiler2 } = (init_URDFCompiler(), __toCommonJS(URDFCompiler_exports));
+        return new URDFCompiler2(opts);
+      },
+      outputExtensions: [".urdf"]
+    },
+    {
+      name: "sdf",
+      domain: "robotics",
+      description: "Compiles to SDF simulation descriptions (Gazebo)",
+      supportedTraits: ["joint", "actuator", "sensor", "collider", "physics", "environment"],
+      riskTier: "standard",
+      factory: (opts) => {
+        const { SDFCompiler: SDFCompiler2 } = (init_SDFCompiler(), __toCommonJS(SDFCompiler_exports));
+        return new SDFCompiler2(opts);
+      },
+      outputExtensions: [".sdf"]
+    },
+    {
+      name: "dtdl",
+      domain: "iot",
+      description: "Compiles to DTDL digital twin definitions",
+      supportedTraits: ["sensor", "telemetry", "property", "command", "relationship"],
+      riskTier: "standard",
+      factory: (opts) => {
+        const { DTDLCompiler: DTDLCompiler2 } = (init_DTDLCompiler(), __toCommonJS(DTDLCompiler_exports));
+        return new DTDLCompiler2(opts);
+      },
+      outputExtensions: [".json"]
+    },
+    // ── Specialized ───────────────────────────────────────────────────────
+    {
+      name: "state",
+      domain: "meta",
+      description: "Extracts reactive state descriptors from compositions",
+      supportedTraits: ["state", "bind", "reactive"],
+      riskTier: "standard",
+      factory: (opts) => {
+        const { StateCompiler: StateCompiler2 } = (init_StateCompiler(), __toCommonJS(StateCompiler_exports));
+        return new StateCompiler2(opts);
+      },
+      outputExtensions: [".json"]
+    },
+    {
+      name: "a2a-agent-card",
+      domain: "ai",
+      description: "Generates A2A Agent Card from composition metadata",
+      supportedTraits: ["agent", "skill", "capability"],
+      riskTier: "standard",
+      factory: (opts) => {
+        const { A2AAgentCardCompiler } = (init_A2AAgentCardCompiler(), __toCommonJS(A2AAgentCardCompiler_exports));
+        return new A2AAgentCardCompiler(opts);
+      },
+      outputExtensions: [".json"]
+    },
+    {
+      name: "nir",
+      domain: "neuromorphic",
+      description: "Compiles to Neuromorphic Intermediate Representation",
+      supportedTraits: ["snn", "neuron", "synapse", "spike_train"],
+      riskTier: "high",
+      factory: (opts) => {
+        const { NIRCompiler } = (init_NIRCompiler(), __toCommonJS(NIRCompiler_exports));
+        return new NIRCompiler(opts);
+      },
+      outputExtensions: [".json"]
+    },
+    {
+      name: "vrr",
+      domain: "xr",
+      description: "Compiles with Variable Rate Rendering optimizations",
+      supportedTraits: ["physics", "material", "lod", "rendering"],
+      riskTier: "standard",
+      factory: (opts) => {
+        const { VRRCompiler } = (init_VRRCompiler(), __toCommonJS(VRRCompiler_exports));
+        return new VRRCompiler(opts);
+      },
+      outputExtensions: [".ts"]
+    },
+    {
+      name: "native-2d",
+      domain: "web3d",
+      description: "Compiles to native 2D HTML/CSS/Canvas applications",
+      supportedTraits: ["layout", "style", "animation", "interaction"],
+      riskTier: "standard",
+      factory: (opts) => {
+        const { Native2DCompiler: Native2DCompiler2 } = (init_Native2DCompiler(), __toCommonJS(Native2DCompiler_exports));
+        return new Native2DCompiler2(opts);
+      },
+      outputExtensions: [".tsx", ".html"]
+    },
+    // ── Next.js API Routes ────────────────────────────────────────────────
+    {
+      name: "nextjs-api",
+      domain: "web",
+      description: "Compiles @http traits to Next.js App Router API route handlers (route.ts)",
+      supportedTraits: ["http", "handler", "middleware", "auth", "rate_limit", "cors"],
+      riskTier: "standard",
+      factory: () => {
+        const { compileToNextJSAPI: compileToNextJSAPI2 } = (init_NextJSAPICompiler(), __toCommonJS(NextJSAPICompiler_exports));
+        return {
+          compile: (composition, _token) => compileToNextJSAPI2(composition)
+        };
+      },
+      outputExtensions: [".ts"],
+      experimental: true
+    },
+    // ── v6 Universal Service ──────────────────────────────────────────────
+    {
+      name: "node-service",
+      domain: "service",
+      description: "Compiles @service traits to Express/Fastify applications",
+      supportedTraits: [
+        "service",
+        "endpoint",
+        "route",
+        "handler",
+        "middleware",
+        "cors_policy",
+        "rate_limiter",
+        "health_endpoint"
+      ],
+      riskTier: "standard",
+      factory: (opts) => {
+        const { NodeServiceCompiler: NodeServiceCompiler2 } = (init_NodeServiceCompiler(), __toCommonJS(NodeServiceCompiler_exports));
+        return new NodeServiceCompiler2(opts);
+      },
+      outputExtensions: [".ts", ".js"],
+      experimental: true
+    }
+  ];
+  for (const desc of descriptors) {
+    if (!DialectRegistry.has(desc.name)) {
+      DialectRegistry.register(desc);
+    }
+  }
+}
+var _registered;
+var init_registerBuiltinDialects = __esm({
+  "src/compiler/registerBuiltinDialects.ts"() {
+    init_DialectRegistry();
+    _registered = false;
+  }
+});
+
+// src/compiler/DialectRegistry.ts
+function ensureDialectsBooted() {
+  if (_autoBooted) return;
+  _autoBooted = true;
+  try {
+    const { registerBuiltinDialects: registerBuiltinDialects2 } = (init_registerBuiltinDialects(), __toCommonJS(registerBuiltinDialects_exports));
+    registerBuiltinDialects2();
+  } catch {
+  }
+}
+var DialectRegistryImpl, DialectRegistry, _autoBooted;
+var init_DialectRegistry = __esm({
+  "src/compiler/DialectRegistry.ts"() {
+    DialectRegistryImpl = class {
+      constructor() {
+        this.dialects = /* @__PURE__ */ new Map();
+      }
+      /**
+       * Register a new compiler dialect.
+       * @throws Error if a dialect with the same name already exists
+       */
+      register(descriptor) {
+        if (this.dialects.has(descriptor.name)) {
+          throw new Error(
+            `Dialect "${descriptor.name}" is already registered. Use DialectRegistry.override() to replace an existing dialect.`
           );
-          lines.push("");
-          for (const mw of middleware) {
-            const fnName = this.toCamelCase(mw) + "Middleware";
-            lines.push(
-              `export function ${fnName}(request: FastifyRequest, _reply: FastifyReply, done: HookHandlerDoneFunction) {`
-            );
-            lines.push(`  // TODO: Implement ${mw} middleware`);
-            lines.push(`  done();`);
-            lines.push(`}`);
-            lines.push("");
-          }
         }
-        return lines.join("\n");
-      }
-      emitPackageJson(projectName) {
-        const name = this.toKebab(projectName || "holoscript-service");
-        const isExpress = this.options.framework === "express";
-        const pkg = {
-          name,
-          version: "0.1.0",
-          description: `Generated by HoloScript NodeServiceCompiler`,
-          main: this.options.typescript ? "dist/index.js" : "index.js",
-          scripts: {
-            ...this.options.typescript ? {
-              build: "tsc",
-              start: "node dist/index.js",
-              dev: "tsx watch index.ts"
-            } : {
-              start: "node index.js",
-              dev: "node --watch index.js"
-            }
-          },
-          dependencies: isExpress ? { express: "^4.21.0" } : { fastify: "^5.0.0" },
-          ...this.options.typescript && {
-            devDependencies: {
-              typescript: "^5.5.0",
-              tsx: "^4.0.0",
-              ...isExpress ? { "@types/express": "^4.17.21", "@types/node": "^20.0.0" } : { "@types/node": "^20.0.0" }
-            }
-          }
-        };
-        return JSON.stringify(pkg, null, 2);
+        if (!descriptor.ansPath) {
+          descriptor.ansPath = `/compile/${descriptor.domain}/${descriptor.name}`;
+        }
+        this.dialects.set(descriptor.name, descriptor);
       }
-      emitTsConfig() {
-        const config = {
-          compilerOptions: {
-            target: "ES2022",
-            module: "NodeNext",
-            moduleResolution: "NodeNext",
-            outDir: "./dist",
-            rootDir: "./",
-            strict: true,
-            esModuleInterop: true,
-            skipLibCheck: true,
-            declaration: true
-          },
-          include: ["./**/*.ts"],
-          exclude: ["node_modules", "dist"]
-        };
-        return JSON.stringify(config, null, 2);
+      /**
+       * Override an existing dialect registration.
+       */
+      override(descriptor) {
+        if (!descriptor.ansPath) {
+          descriptor.ansPath = `/compile/${descriptor.domain}/${descriptor.name}`;
+        }
+        this.dialects.set(descriptor.name, descriptor);
       }
-      emitDockerfile() {
-        const nodeVer = this.options.nodeVersion;
-        return [
-          `FROM node:${nodeVer}-alpine AS builder`,
-          `WORKDIR /app`,
-          `COPY package*.json ./`,
-          `RUN npm ci`,
-          `COPY . .`,
-          ...this.options.typescript ? [`RUN npm run build`] : [],
-          ``,
-          `FROM node:${nodeVer}-alpine`,
-          `WORKDIR /app`,
-          `COPY --from=builder /app/package*.json ./`,
-          `RUN npm ci --omit=dev`,
-          ...this.options.typescript ? [`COPY --from=builder /app/dist ./dist`] : [`COPY --from=builder /app/*.js ./`],
-          `EXPOSE ${this.options.port}`,
-          `CMD ["npm", "start"]`,
-          ``
-        ].join("\n");
+      /**
+       * Unregister a dialect.
+       */
+      unregister(name) {
+        return this.dialects.delete(name);
       }
-      // ── Utilities ──────────────────────────────────────────────────────────
-      /** Convert HoloObjectProperty[] to a Map for key-based lookup */
-      objectPropsToMap(props) {
-        const map = /* @__PURE__ */ new Map();
-        if (!props) return map;
-        for (const prop of props) {
-          map.set(prop.key, prop.value);
+      /**
+       * Check if a dialect is registered.
+       */
+      has(name) {
+        return this.dialects.has(name);
+      }
+      /**
+       * Get dialect info (without factory, safe for discovery).
+       */
+      get(name) {
+        const desc = this.dialects.get(name);
+        if (!desc) return void 0;
+        return {
+          name: desc.name,
+          domain: desc.domain,
+          description: desc.description,
+          supportedTraits: desc.supportedTraits,
+          riskTier: desc.riskTier,
+          ansPath: desc.ansPath || `/compile/${desc.domain}/${desc.name}`,
+          outputExtensions: desc.outputExtensions || [],
+          experimental: desc.experimental ?? false
+        };
+      }
+      /**
+       * Create a compiler instance from a registered dialect.
+       * @throws Error if dialect not found
+       */
+      create(name, options) {
+        const desc = this.dialects.get(name);
+        if (!desc) {
+          const available = [...this.dialects.keys()].join(", ");
+          throw new Error(`Unknown dialect "${name}". Available: ${available}`);
         }
-        return map;
+        return desc.factory(options);
       }
-      ext(name) {
-        return this.options.typescript ? `${name}.ts` : `${name}.js`;
+      /**
+       * List all registered dialects.
+       */
+      list() {
+        return [...this.dialects.values()].map((desc) => ({
+          name: desc.name,
+          domain: desc.domain,
+          description: desc.description,
+          supportedTraits: desc.supportedTraits,
+          riskTier: desc.riskTier,
+          ansPath: desc.ansPath || `/compile/${desc.domain}/${desc.name}`,
+          outputExtensions: desc.outputExtensions || [],
+          experimental: desc.experimental ?? false
+        }));
       }
-      toFileName(name) {
-        return name.replace(/[^a-zA-Z0-9]/g, "-").replace(/-+/g, "-");
+      /**
+       * List dialects filtered by domain.
+       */
+      listByDomain(domain) {
+        return this.list().filter((d) => d.domain === domain);
       }
-      toKebab(name) {
-        return name.replace(/([a-z])([A-Z])/g, "$1-$2").replace(/[^a-zA-Z0-9]/g, "-").replace(/-+/g, "-").toLowerCase();
+      /**
+       * Find dialects that support a specific trait.
+       */
+      findByTrait(traitName) {
+        return this.list().filter((d) => d.supportedTraits.includes(traitName));
       }
-      toCamelCase(name) {
-        const parts = name.replace(/[^a-zA-Z0-9]/g, " ").split(/\s+/).filter(Boolean);
-        if (parts.length === 0) return "unnamed";
-        return parts[0].toLowerCase() + parts.slice(1).map((p) => p.charAt(0).toUpperCase() + p.slice(1).toLowerCase()).join("");
+      /**
+       * Get all registered dialect names.
+       */
+      names() {
+        return [...this.dialects.keys()];
       }
-      resolveString(val) {
-        if (val === void 0 || val === null) return void 0;
-        if (typeof val === "string") return val;
-        if (typeof val === "object" && "value" in val) return String(val.value);
-        return String(val);
+      /**
+       * Get count of registered dialects.
+       */
+      get size() {
+        return this.dialects.size;
       }
-      resolveNumber(val) {
-        if (val === void 0 || val === null) return void 0;
-        if (typeof val === "number") return val;
-        if (typeof val === "string") {
-          const n = Number(val);
-          return isNaN(n) ? void 0 : n;
+      /**
+       * Execute a progressive lowering pipeline for a dialect.
+       * Runs all registered lowering passes in priority order.
+       */
+      executeLoweringPipeline(dialectName, composition, options = {}) {
+        const desc = this.dialects.get(dialectName);
+        if (!desc) {
+          throw new Error(`Unknown dialect "${dialectName}"`);
         }
-        if (typeof val === "object" && "value" in val) {
-          const n = Number(val.value);
-          return isNaN(n) ? void 0 : n;
+        const passes = [...desc.loweringPasses || []].sort((a, b) => a.priority - b.priority);
+        if (passes.length === 0) {
+          throw new Error(
+            `Dialect "${dialectName}" has no lowering passes. Use create() for direct compilation.`
+          );
         }
-        return void 0;
+        const context = {
+          target: dialectName,
+          options,
+          previousPasses: /* @__PURE__ */ new Map(),
+          diagnostics: []
+        };
+        let lastResult = { output: "" };
+        for (const pass of passes) {
+          lastResult = pass.lower(composition, context);
+          context.previousPasses.set(pass.name, lastResult);
+          if (lastResult.diagnostics) {
+            context.diagnostics.push(...lastResult.diagnostics);
+          }
+          const hasError = lastResult.diagnostics?.some((d) => d.level === "error");
+          if (hasError) break;
+        }
+        lastResult.diagnostics = context.diagnostics;
+        return lastResult;
       }
     };
-    DialectRegistry.register({
-      name: "node-service",
-      domain: "service",
-      description: "Compiles @service traits to Express/Fastify Node.js applications",
-      supportedTraits: [
-        "service",
-        "endpoint",
-        "route",
-        "handler",
-        "middleware",
-        "http",
-        "gateway",
-        "proxy",
-        "load_balancer",
-        "auth",
-        "cors",
-        "rate_limit",
-        "validation"
-      ],
-      riskTier: "standard",
-      factory: (options) => new NodeServiceCompiler(options),
-      outputExtensions: [".ts", ".js", ".json"],
-      experimental: true
-    });
+    DialectRegistry = new DialectRegistryImpl();
+    _autoBooted = false;
   }
 });
 
@@ -1310,12 +2054,330 @@ init_SDFCompiler();
 init_DTDLCompiler();
 init_URDFCompiler();
 init_StateCompiler();
+
+// src/compiler/NextJSCompiler.ts
+init_CompilerBase();
+init_Native2DCompiler();
+function findTrait(composition, traitName) {
+  const traits = composition.traits;
+  if (!traits) return null;
+  const found = traits.find((t) => t.name === traitName);
+  return found?.config || null;
+}
+var NextJSCompiler = class extends CompilerBase {
+  constructor(options = {}) {
+    super();
+    this.options = options;
+    this.compilerName = "NextJSCompiler";
+  }
+  /**
+   * Compile HoloComposition AST to Next.js App Router Code
+   *
+   * @param composition - HoloScript AST
+   * @param agentToken - JWT or UCAN token proving agent identity
+   * @param outputPath - Optional output file path for scope validation
+   * @param sceneGraph - Optional pre-computed SSG
+   */
+  async compile(composition, agentToken, outputPath, _sceneGraph) {
+    this.validateCompilerAccess(agentToken, outputPath);
+    return this.buildNextRoute(composition);
+  }
+  validateCompilerAccess(agentToken, outputPath) {
+    if (typeof agentToken === "object" && agentToken !== null) {
+      this.validateCapabilityAccess(agentToken, outputPath);
+    } else {
+      this.validateASTAccess(agentToken);
+      this.validateCodeGeneration(agentToken);
+      if (outputPath) {
+        this.validateOutputPath(agentToken, outputPath);
+      }
+      this.validateSpatialZoneAccess(agentToken);
+    }
+  }
+  buildNextRoute(composition) {
+    const compiler = new Native2DCompiler();
+    const pageTrait = findTrait(composition, "page");
+    const metaTrait = findTrait(composition, "metadata");
+    const route = pageTrait?.route || `/${composition.name.toLowerCase().replace(/\s+/g, "-")}`;
+    const isClient = pageTrait?.client !== false;
+    const slotMap = this.options.slots || {};
+    if (pageTrait?.redirect) {
+      const redirectUrl = pageTrait.redirect;
+      const lines2 = [
+        `// @generated by HoloScript NextJSCompiler \u2014 DO NOT EDIT`,
+        `import { redirect } from 'next/navigation';`,
+        ``,
+        `export default function RedirectPage() {`,
+        `  redirect(${JSON.stringify(redirectUrl)});`,
+        `}`
+      ];
+      if (metaTrait) {
+        const metaEntries = [];
+        if (metaTrait.title) metaEntries.push(`  title: ${JSON.stringify(metaTrait.title)},`);
+        if (metaTrait.description)
+          metaEntries.push(`  description: ${JSON.stringify(metaTrait.description)},`);
+        lines2.push("");
+        lines2.push(`export const metadata = {`);
+        lines2.push(metaEntries.join("\n"));
+        lines2.push(`};`);
+      }
+      const routePath2 = route.replace(/^\//, "") || "index";
+      return {
+        path: `${routePath2}/page.tsx`,
+        code: lines2.join("\n")
+      };
+    }
+    const compilerOptions = {
+      format: "react",
+      useUIComponents: true,
+      slots: slotMap
+    };
+    const elements = composition.ui?.elements || composition.objects || [];
+    const componentCode = compiler.generateReactComponent(
+      composition.name,
+      elements,
+      composition,
+      compilerOptions
+    );
+    const pageSafeComponentCode = componentCode.replace(
+      /export\s+function\s+([A-Za-z0-9_]+)\s*\(/,
+      "function $1("
+    );
+    const lines = [];
+    if (isClient) {
+      lines.push("'use client';");
+      lines.push("");
+    }
+    lines.push(pageSafeComponentCode);
+    if (metaTrait && !isClient) {
+      const metaEntries = [];
+      if (metaTrait.title) metaEntries.push(`  title: ${JSON.stringify(metaTrait.title)},`);
+      if (metaTrait.description)
+        metaEntries.push(`  description: ${JSON.stringify(metaTrait.description)},`);
+      lines.push("");
+      lines.push(`export const metadata = {`);
+      lines.push(metaEntries.join("\n"));
+      lines.push(`};`);
+    }
+    const routePath = route.replace(/^\//, "") || "index";
+    return {
+      path: `${routePath}/page.tsx`,
+      code: lines.join("\n")
+    };
+  }
+};
+
+// src/compiler/index.ts
 init_NextJSAPICompiler();
+
+// src/compiler/MCPConfigCompiler.ts
+init_CompilerBase();
+init_DialectRegistry();
+var MCPConfigCompiler = class extends CompilerBase {
+  constructor(options = {}) {
+    super();
+    this.compilerName = "MCPConfigCompiler";
+    this.servers = [];
+    this.options = {
+      target: options.target ?? "generic",
+      envFile: options.envFile ?? "",
+      envValues: options.envValues ?? {},
+      cwd: options.cwd ?? ""
+    };
+  }
+  compile(composition, agentToken, outputPath) {
+    this.validateCompilerAccess(agentToken, outputPath);
+    this.servers = [];
+    if (composition.domainBlocks) {
+      for (const block of composition.domainBlocks) {
+        if (block.domain === "mcp_servers" || block.name === "mcp_servers") {
+          this.extractServersFromBlock(block);
+        }
+      }
+    }
+    if (composition.objects) {
+      for (const obj of composition.objects) {
+        if (this.hasConnectorTrait(obj)) {
+          this.servers.push(this.extractServerFromObject(obj));
+        }
+      }
+    }
+    const config = this.generateConfig();
+    return JSON.stringify(config, null, 2);
+  }
+  // ── Extraction ────────────────────────────────────────────────────────────
+  extractServersFromBlock(block) {
+    if (!block.children) return;
+    for (const child of block.children) {
+      if ("type" in child && child.type === "ObjectDecl") {
+        const obj = child;
+        this.servers.push(this.extractServerFromObject(obj));
+      }
+    }
+  }
+  extractServerFromObject(obj) {
+    const props = this.objectPropsToMap(obj.properties);
+    const traits = obj.traits || [];
+    let transport = "http";
+    const connectorTrait = traits.find((t) => t.name === "connector");
+    if (connectorTrait?.config) {
+      const t = this.resolveString(connectorTrait.config["transport"] || connectorTrait.config["_arg1"]);
+      if (t === "stdio" || t === "sse" || t === "http") transport = t;
+    }
+    const envVars = [];
+    for (const trait of traits) {
+      if (trait.name === "env") {
+        const varName = this.resolveString(trait.config["_arg0"] || trait.config["name"] || "");
+        const header = this.resolveString(trait.config["header"] || "");
+        if (varName) {
+          envVars.push({ name: varName, header: header || void 0 });
+        }
+      }
+    }
+    return {
+      name: obj.name,
+      transport,
+      url: this.resolveString(props.get("url")),
+      command: this.resolveString(props.get("command")),
+      args: this.resolveArray(props.get("args")),
+      cwd: this.resolveString(props.get("cwd")),
+      description: this.resolveString(props.get("description")),
+      envVars
+    };
+  }
+  hasConnectorTrait(obj) {
+    return (obj.traits || []).some((t) => t.name === "connector");
+  }
+  // ── Config Generation ─────────────────────────────────────────────────────
+  generateConfig() {
+    const mcpServers = {};
+    for (const server of this.servers) {
+      mcpServers[server.name] = this.generateServerEntry(server);
+    }
+    const config = {
+      _generated: "HoloScript MCPConfigCompiler",
+      _target: this.options.target,
+      _updated: (/* @__PURE__ */ new Date()).toISOString().split("T")[0],
+      mcpServers
+    };
+    if (this.options.target === "claude") {
+      config["$schema"] = "https://modelcontextprotocol.io/schemas/mcp-config.json";
+    }
+    return config;
+  }
+  generateServerEntry(server) {
+    const entry = {};
+    if (server.transport === "stdio") {
+      entry.command = server.command || "node";
+      if (server.args) entry.args = server.args;
+      if (server.cwd || this.options.target === "antigravity") {
+        entry.cwd = server.cwd || this.options.cwd || void 0;
+      }
+      const envBlock = {};
+      for (const ev of server.envVars) {
+        if (!ev.header) {
+          envBlock[ev.name] = this.resolveEnvValue(ev.name);
+        }
+      }
+      if (Object.keys(envBlock).length > 0) {
+        entry.env = envBlock;
+      }
+    } else {
+      if (this.options.target === "antigravity") {
+        entry.serverURL = server.url;
+      } else {
+        entry.url = server.url;
+      }
+      if (this.options.target !== "antigravity" && server.transport === "sse") {
+        entry.transport = "sse";
+      }
+      const headers = {};
+      for (const ev of server.envVars) {
+        if (ev.header) {
+          const [headerName, ...prefix] = ev.header.split(":");
+          const prefixStr = prefix.join(":").trim();
+          const value = this.resolveEnvValue(ev.name);
+          headers[headerName.trim()] = prefixStr ? `${prefixStr} ${value}` : value;
+        } else {
+          headers[ev.name] = this.resolveEnvValue(ev.name);
+        }
+      }
+      if (Object.keys(headers).length > 0) {
+        entry.headers = headers;
+      }
+    }
+    if (server.description) {
+      entry.description = server.description;
+    }
+    return entry;
+  }
+  // ── Env Value Resolution ──────────────────────────────────────────────────
+  resolveEnvValue(varName) {
+    switch (this.options.target) {
+      case "antigravity":
+        return this.options.envValues[varName] || this.readEnvFile(varName) || `MISSING_${varName}`;
+      case "vscode":
+        return `\${env:${varName}}`;
+      case "claude":
+      case "cursor":
+      case "generic":
+      default:
+        return `\${${varName}}`;
+    }
+  }
+  readEnvFile(varName) {
+    if (!this.options.envFile) return void 0;
+    try {
+      return this.options.envValues[varName];
+    } catch {
+      return void 0;
+    }
+  }
+  // ── Helpers ───────────────────────────────────────────────────────────────
+  objectPropsToMap(props) {
+    const map = /* @__PURE__ */ new Map();
+    if (!props) return map;
+    for (const prop of props) {
+      map.set(prop.key, prop.value);
+    }
+    return map;
+  }
+  resolveString(value) {
+    if (!value) return void 0;
+    if (typeof value === "string") return value;
+    if (typeof value === "object" && "value" in value) {
+      return String(value.value);
+    }
+    return String(value);
+  }
+  resolveArray(value) {
+    if (!value) return void 0;
+    if (Array.isArray(value)) {
+      return value.map((v) => {
+        if (typeof v === "string") return v;
+        if (typeof v === "object" && v && "value" in v) return String(v.value);
+        return String(v);
+      });
+    }
+    return void 0;
+  }
+};
+DialectRegistry.register({
+  name: "mcp-config",
+  domain: "configuration",
+  description: "Compiles .holo server definitions to IDE-specific MCP config JSON",
+  supportedTraits: ["connector", "env"],
+  factory: (options) => new MCPConfigCompiler(options),
+  inputFormats: [".holo"],
+  outputFormat: ".json"
+});
+
+// src/compiler/index.ts
 init_Native2DCompiler();
 init_NodeServiceCompiler();
 init_DialectRegistry();
 init_registerBuiltinDialects();
 
-export { DialectRegistry, NodeServiceCompiler, compileAllToNextJSAPI, compileToNextJSAPI, ensureDialectsBooted, registerBuiltinDialects };
+export { DialectRegistry, MCPConfigCompiler, Native2DCompiler, NextJSCompiler, NodeServiceCompiler, compileAllToNextJSAPI, compileToNextJSAPI, ensureDialectsBooted, registerBuiltinDialects };
 //# sourceMappingURL=index.js.map
 //# sourceMappingURL=index.js.map