@kithinji/pod 1.0.31 → 1.0.32

package/dist/main.js

@@ -11,7 +11,7 @@ import { Command } from "commander";
 // src/dev/server.ts
 import * as esbuild2 from "esbuild";
 import { spawn } from "child_process";
-import * as fs6 from "fs/promises";
+import * as fs7 from "fs/promises";
 import { WebSocketServer, WebSocket } from "ws";
 
 // src/config/config.ts
@@ -55,8 +55,8 @@ async function loadJsConfig(configPath) {
 }
 async function loadTsConfig(configPath) {
   try {
-    const esbuild3 = await import("esbuild");
-    const result = await esbuild3.build({
+    const esbuild4 = await import("esbuild");
+    const result = await esbuild4.build({
       entryPoints: [configPath],
       bundle: true,
       platform: "node",
@@ -93,7 +93,9 @@ function getDefaultConfig() {
     build: {
       outDir: "dist",
       sourcemap: true,
-      minify: false
+      minify: false,
+      types: false,
+      decorators: false
     },
     plugins: [],
     client_plugins: [],
@@ -121,6 +123,7 @@ var plugins_exports = {};
 __export(plugins_exports, {
   buildGraph: () => buildGraph,
   stylePlugin: () => stylePlugin,
+  useCompilePlugin: () => useCompilePlugin,
   useMyPlugin: () => useMyPlugin
 });
 
@@ -137,6 +140,7 @@ __export(macros_exports, {
   expandMacros: () => expandMacros,
   extractValueFromNode: () => extractValueFromNode,
   getGlobalMacroGraph: () => getGlobalMacroGraph,
+  macroContext: () => macroContext,
   macroExecuter: () => macroExecuter,
   resetGlobalMacroGraph: () => resetGlobalMacroGraph
 });
@@ -353,6 +357,22 @@ var Store = class _Store {
 };
 
 // src/macros/expand_macros.ts
+var currentMacroContext = null;
+function macroContext() {
+  if (!currentMacroContext) {
+    throw new Error("macroContext() called outside of macro execution");
+  }
+  return currentMacroContext;
+}
+function withMacroContext(context2, fn) {
+  const previousContext = currentMacroContext;
+  currentMacroContext = context2;
+  try {
+    return fn();
+  } finally {
+    currentMacroContext = previousContext;
+  }
+}
 var MacroDependencyGraph = class {
   constructor(projectRoot) {
     this.nodes = /* @__PURE__ */ new Map();
@@ -406,17 +426,17 @@ var MacroDependencyGraph = class {
     const visited = /* @__PURE__ */ new Set();
     const inProgress = /* @__PURE__ */ new Set();
     const sorted = [];
-    const visit = (key, path16 = []) => {
+    const visit = (key, path17 = []) => {
       if (visited.has(key)) return;
       if (inProgress.has(key)) {
-        const cycle = [...path16, key].join(" -> ");
+        const cycle = [...path17, key].join(" -> ");
         throw new Error(`Circular macro dependency detected: ${cycle}`);
       }
       const node = this.nodes.get(key);
       if (!node) return;
       inProgress.add(key);
       for (const depKey of node.dependencies) {
-        visit(depKey, [...path16, key]);
+        visit(depKey, [...path17, key]);
       }
       inProgress.delete(key);
       visited.add(key);
@@ -812,7 +832,7 @@ async function expandMacros(source, filePath, projectRoot = process.cwd()) {
       macroNode.sourceFile,
       compilerOptions
     );
-    const macroContext = {
+    const macroContext2 = {
       node,
       sourceFile: macroNode.sourceFile,
       ts,
@@ -832,7 +852,10 @@ async function expandMacros(source, filePath, projectRoot = process.cwd()) {
       resolveIdentifier: resolver.resolveIdentifierToNode
     };
     try {
-      const result2 = macro(...node.arguments, macroContext);
+      const result2 = withMacroContext(
+        macroContext2,
+        () => macro(...node.arguments)
+      );
       if (!result2 || typeof result2 !== "object" || !("kind" in result2)) {
         throw new Error(`Macro '${name}' must return a TypeScript AST node`);
       }
@@ -878,7 +901,7 @@ async function expandMacros(source, filePath, projectRoot = process.cwd()) {
                 sourceFile,
                 compilerOptions
               );
-              const macroContext = {
+              const macroContext2 = {
                 node,
                 sourceFile,
                 ts,
@@ -898,7 +921,10 @@ async function expandMacros(source, filePath, projectRoot = process.cwd()) {
                 resolveIdentifier: resolver.resolveIdentifierToNode
               };
               try {
-                const result2 = macro(...node.arguments, macroContext);
+                const result2 = withMacroContext(
+                  macroContext2,
+                  () => macro(...node.arguments)
+                );
                 if (!result2 || typeof result2 !== "object" || !("kind" in result2)) {
                   throw new Error(
                     `Macro '${name}' must return a TypeScript AST node`
@@ -1629,16 +1655,16 @@ var ASTUtilities = class {
     });
     return cloned;
   }
-  walkAndTransform(node, transform2) {
+  walkAndTransform(node, transform3) {
     if (!node || typeof node !== "object") return;
-    transform2(node);
+    transform3(node);
     for (const key in node) {
       if (this.shouldSkipKey(key)) continue;
       const value = node[key];
       if (Array.isArray(value)) {
-        value.forEach((item) => this.walkAndTransform(item, transform2));
+        value.forEach((item) => this.walkAndTransform(item, transform3));
       } else if (value && typeof value === "object") {
-        this.walkAndTransform(value, transform2);
+        this.walkAndTransform(value, transform3);
       }
     }
   }
@@ -1798,22 +1824,22 @@ var ElementTransformer = class {
     this.jsxUtils = jsxUtils;
     this.observableManager = observableManager;
   }
-  transformElement(path16, scope, context2) {
-    if (this.t.isJSXFragment(path16.node)) {
+  transformElement(path17, scope, context2) {
+    if (this.t.isJSXFragment(path17.node)) {
       return this.transformFragment(
-        path16,
+        path17,
         scope,
         context2
       );
     }
     return this.transformJSXElement(
-      path16,
+      path17,
       scope,
       context2
     );
   }
-  transformJSXElement(path16, scope, context2) {
-    const jsxElement = path16.node;
+  transformJSXElement(path17, scope, context2) {
+    const jsxElement = path17.node;
     const tag = this.jsxUtils.getComponentName(jsxElement.openingElement.name);
     const isComponent = this.jsxUtils.isComponentTag(tag);
     if (isComponent && tag) {
@@ -1928,7 +1954,7 @@ var ElementTransformer = class {
     }
     return { id: elId, statements };
   }
-  transformFragment(path16, scope, context2) {
+  transformFragment(path17, scope, context2) {
     const fragId = scope.generateUidIdentifier("frag");
     const statements = [];
     statements.push(
@@ -1946,7 +1972,7 @@ var ElementTransformer = class {
       ])
     );
     this.processDOMChildren(
-      path16.node.children,
+      path17.node.children,
       fragId,
       statements,
       scope,
@@ -2335,7 +2361,7 @@ function j2d({ types: t }) {
     name: "jsx-to-dom",
     visitor: {
       Program: {
-        exit(path16, state) {
+        exit(path17, state) {
           if (state.helpersImported) return;
           const helpers = [
             { local: "$insert", imported: "insert" },
@@ -2346,7 +2372,7 @@ function j2d({ types: t }) {
             { local: "$effect", imported: "effect" }
           ];
           for (const helper of helpers) {
-            path16.unshiftContainer(
+            path17.unshiftContainer(
               "body",
               t.importDeclaration(
                 [
@@ -2362,10 +2388,10 @@ function j2d({ types: t }) {
           state.helpersImported = true;
         }
       },
-      ClassMethod(path16) {
-        if (path16.getData("processed")) return;
+      ClassMethod(path17) {
+        if (path17.getData("processed")) return;
         let hasJSX = false;
-        path16.traverse({
+        path17.traverse({
           JSXElement() {
             hasJSX = true;
           },
@@ -2374,11 +2400,11 @@ function j2d({ types: t }) {
           }
         });
         if (!hasJSX) return;
-        path16.setData("processed", true);
-        const body = path16.node.body;
+        path17.setData("processed", true);
+        const body = path17.node.body;
         if (!t.isBlockStatement(body)) return;
         const observables = /* @__PURE__ */ new Map();
-        path16.traverse({
+        path17.traverse({
           JSXElement(jsxPath) {
             observableManager.collectObservables(
               jsxPath.node,
@@ -2402,7 +2428,7 @@ function j2d({ types: t }) {
         const observableSignals = /* @__PURE__ */ new Map();
         const signalDeclarations = [];
         for (const [key, observable] of observables) {
-          const signalId = path16.scope.generateUidIdentifier("sig");
+          const signalId = path17.scope.generateUidIdentifier("sig");
           observableSignals.set(key, signalId);
           signalDeclarations.push(
             t.variableDeclaration("const", [
@@ -2420,7 +2446,7 @@ function j2d({ types: t }) {
           astUtils.insertBeforeReturn(body.body, signalDeclarations);
         }
         const context2 = { observables, observableSignals };
-        path16.traverse({
+        path17.traverse({
           JSXElement(jsxPath) {
             if (jsxPath.getData("processed")) return;
             jsxPath.setData("processed", true);
@@ -2729,8 +2755,8 @@ function stringifyType3(typeNode) {
 }
 function generateStubCode(stub) {
   const className = stub.name;
-  const build = stub.methods.find((p) => p.name == "build");
-  if (build == void 0) {
+  const build2 = stub.methods.find((p) => p.name == "build");
+  if (build2 == void 0) {
     throw new Error("Component has no build function");
   }
   const decoratorsStr = stub.decorators.length > 0 ? stub.decorators.join("\n") + "\n" : "";
@@ -2953,8 +2979,8 @@ async function swcTransform(source, pathStr, tsx = false, react) {
     resolveDir
   };
 }
-function parseFileMetadata(source, path16) {
-  const isTsx = path16.endsWith(".tsx");
+function parseFileMetadata(source, path17) {
+  const isTsx = path17.endsWith(".tsx");
   const isClientFile = source.startsWith('"use client"') || source.startsWith("'use client'");
   const isPublicFile = source.startsWith('"use public"') || source.startsWith("'use public'");
   let directive = null;
@@ -2962,7 +2988,7 @@ function parseFileMetadata(source, path16) {
   else if (isPublicFile) directive = "public";
   return {
     source,
-    path: path16,
+    path: path17,
     isTsx,
     directive,
     isPublicFile,
@@ -2970,58 +2996,58 @@ function parseFileMetadata(source, path16) {
   };
 }
 var ServerBuildTransformer = class {
-  async transformPublicFile(source, path16) {
-    const controllerCode = generateController(path16, source);
+  async transformPublicFile(source, path17) {
+    const controllerCode = generateController(path17, source);
     if (controllerCode) {
       source = `${source}
 
 ${controllerCode}
 `;
     }
-    return swcTransform(source, path16);
+    return swcTransform(source, path17);
   }
-  async transformRegularTypeScript(source, path16, isPublic) {
+  async transformRegularTypeScript(source, path17, isPublic) {
     if (isPublic) {
-      return this.transformPublicFile(source, path16);
+      return this.transformPublicFile(source, path17);
     }
-    return swcTransform(source, path16);
+    return swcTransform(source, path17);
   }
-  async transformServerTsx(source, path16) {
-    return swcTransform(source, path16, true, {
+  async transformServerTsx(source, path17) {
+    return swcTransform(source, path17, true, {
       runtime: "automatic",
       importSource: "@kithinji/orca"
     });
   }
-  async transformClientTsxStub(source, path16) {
-    const stubSource = generateServerStub(path16, source);
-    return swcTransform(stubSource, path16);
+  async transformClientTsxStub(source, path17) {
+    const stubSource = generateServerStub(path17, source);
+    return swcTransform(stubSource, path17);
   }
   async process(metadata, onClientFound) {
     const expandedSource = await expandMacros(metadata.source, metadata.path);
     const expandedMetadata = { ...metadata, source: expandedSource };
-    const { source, path: path16, isTsx, isClientFile, isPublicFile } = expandedMetadata;
+    const { source, path: path17, isTsx, isClientFile, isPublicFile } = expandedMetadata;
     if (isTsx) {
       if (isClientFile) {
-        onClientFound(path16);
-        const clientCode = await this.transformClientTsxStub(source, path16);
+        onClientFound(path17);
+        const clientCode = await this.transformClientTsxStub(source, path17);
         const store = Store.getInstance();
-        store.set(path16, clientCode.contents);
+        store.set(path17, clientCode.contents);
         return clientCode;
       }
-      return this.transformServerTsx(source, path16);
+      return this.transformServerTsx(source, path17);
     }
-    return this.transformRegularTypeScript(source, path16, isPublicFile);
+    return this.transformRegularTypeScript(source, path17, isPublicFile);
   }
 };
 var ClientBuildTransformer = class {
-  async transformClientTsx(source, path16) {
-    const swcResult = await swcTransform(source, path16, true, {
+  async transformClientTsx(source, path17) {
+    const swcResult = await swcTransform(source, path17, true, {
       runtime: "preserve"
     });
     const babelResult = await babel.transformAsync(
       swcResult.contents,
       {
-        filename: path16,
+        filename: path17,
         sourceType: "module",
         plugins: [j2d],
         parserOpts: {
@@ -3037,37 +3063,37 @@ var ClientBuildTransformer = class {
       resolveDir: swcResult.resolveDir
     };
   }
-  async transformServerComponent(node, source, path16) {
-    const scSource = generateServerComponent(path16, source);
-    return swcTransform(scSource, path16);
+  async transformServerComponent(node, source, path17) {
+    const scSource = generateServerComponent(path17, source);
+    return swcTransform(scSource, path17);
   }
-  async transformPublicFileRpc(node, source, path16) {
-    const stubSource = generateRpcStub(path16, source);
-    return swcTransform(stubSource, path16);
+  async transformPublicFileRpc(node, source, path17) {
+    const stubSource = generateRpcStub(path17, source);
+    return swcTransform(stubSource, path17);
   }
-  async transformSharedCode(source, path16) {
-    return swcTransform(source, path16);
+  async transformSharedCode(source, path17) {
+    return swcTransform(source, path17);
   }
   async process(node, metadata) {
     const expandedSource = await expandMacros(metadata.source, metadata.path);
     const expandedMetadata = { ...metadata, source: expandedSource };
-    const { source, path: path16, isTsx, directive } = expandedMetadata;
+    const { source, path: path17, isTsx, directive } = expandedMetadata;
     if (isTsx) {
       if (directive === "client") {
-        return this.transformClientTsx(source, path16);
+        return this.transformClientTsx(source, path17);
       } else if (directive === null) {
-        return this.transformServerComponent(node, source, path16);
+        return this.transformServerComponent(node, source, path17);
       } else {
         throw new Error(
-          `Unexpected directive "${directive}" for TSX file: ${path16}`
+          `Unexpected directive "${directive}" for TSX file: ${path17}`
         );
       }
     }
     if (directive === "public") {
-      return this.transformPublicFileRpc(node, source, path16);
+      return this.transformPublicFileRpc(node, source, path17);
     }
     if (directive === null) {
-      return this.transformSharedCode(source, path16);
+      return this.transformSharedCode(source, path17);
     }
     return {
       contents: source,
@@ -3080,8 +3106,8 @@ function useMyPlugin(options) {
   const clientTransformer = new ClientBuildTransformer();
   return {
     name: "Orca",
-    setup(build) {
-      build.onLoad(
+    setup(build2) {
+      build2.onLoad(
         { filter: /\.tsx?$/ },
         async (args) => {
           const source = await fs2.readFile(args.path, "utf8");
@@ -3307,8 +3333,8 @@ import * as fs4 from "fs";
 function stylePlugin(store) {
   return {
     name: "style",
-    setup(build) {
-      build.onEnd(() => {
+    setup(build2) {
+      build2.onEnd(() => {
         const styleRules = store.get("style_rules");
         if (!styleRules || styleRules.length === 0) {
           console.log("No style rules generated");
@@ -3323,16 +3349,90 @@ function stylePlugin(store) {
   };
 }
 
-// src/html/index.ts
+// src/plugins/compile.ts
 import * as fs5 from "fs/promises";
+import * as path8 from "path";
+import { transform as transform2 } from "@swc/core";
+function parseFileMetadata2(source, path17, decorators) {
+  return {
+    source,
+    path: path17,
+    decorators
+  };
+}
+async function swcTransform2(source, pathStr, tsx = false, react) {
+  const resolveDir = path8.dirname(pathStr);
+  const swcResult = await transform2(source, {
+    filename: pathStr,
+    jsc: {
+      parser: {
+        syntax: "typescript",
+        tsx,
+        decorators: true
+      },
+      transform: {
+        legacyDecorator: true,
+        decoratorMetadata: true,
+        react
+      },
+      target: "esnext"
+    },
+    isModule: true
+  });
+  return {
+    contents: swcResult.code,
+    loader: "js",
+    resolveDir
+  };
+}
+var BuildTransformer = class {
+  async transformTypeScript(source, path17) {
+    return swcTransform2(source, path17);
+  }
+  async process(metadata) {
+    const expandedSource = await expandMacros(metadata.source, metadata.path);
+    const expandedMetadata = { ...metadata, source: expandedSource };
+    const { source, path: path17, decorators } = expandedMetadata;
+    if (!decorators) {
+      return {
+        contents: source,
+        loader: "ts"
+      };
+    }
+    return this.transformTypeScript(source, path17);
+  }
+};
+function useCompilePlugin(options) {
+  const transformer = new BuildTransformer();
+  return {
+    name: "Orca",
+    setup(build2) {
+      build2.onLoad(
+        { filter: /\.tsx?$/ },
+        async (args) => {
+          const source = await fs5.readFile(args.path, "utf8");
+          const metadata = parseFileMetadata2(
+            source,
+            args.path,
+            options.decorators
+          );
+          return transformer.process(metadata);
+        }
+      );
+    }
+  };
+}
+
+// src/html/index.ts
+import * as fs6 from "fs/promises";
 var HtmlPreprocessor = class {
   constructor(options = {}) {
     this.options = options;
   }
   async processFile(inputPath, outputPath) {
-    const html = await fs5.readFile(inputPath, "utf-8");
+    const html = await fs6.readFile(inputPath, "utf-8");
     const processed = await this.process(html);
-    await fs5.writeFile(outputPath, processed, "utf-8");
+    await fs6.writeFile(outputPath, processed, "utf-8");
   }
   async process(html) {
     let result = html;
@@ -3469,8 +3569,8 @@ export async function navigate(event, url) {
 function createVirtualModulePlugin(virtualFiles) {
   return {
     name: "virtual-module",
-    setup(build) {
-      build.onResolve({ filter: /^virtual:/ }, (args) => {
+    setup(build2) {
+      build2.onResolve({ filter: /^virtual:/ }, (args) => {
         if (virtualFiles[args.path]) {
           return {
             path: args.path,
@@ -3478,7 +3578,7 @@ function createVirtualModulePlugin(virtualFiles) {
           };
         }
       });
-      build.onLoad({ filter: /.*/, namespace: "virtual" }, (args) => {
+      build2.onLoad({ filter: /.*/, namespace: "virtual" }, (args) => {
         const virtualFile = virtualFiles[args.path];
         if (virtualFile) {
           return {
@@ -3535,7 +3635,7 @@ var HotReloadManager = class {
 };
 async function copyAndProcessHtml(hotReloadPort, preprocessorOptions) {
   try {
-    await fs6.mkdir("public", { recursive: true });
+    await fs7.mkdir("public", { recursive: true });
     const preprocessor = new HtmlPreprocessor({
       transformers: [createHotReloadTransformer(hotReloadPort)],
       injectScripts: ["./navigate.js"],
@@ -3552,15 +3652,15 @@ async function copyAndProcessHtml(hotReloadPort, preprocessorOptions) {
 }
 async function cleanDirectories() {
   await Promise.all([
-    fs6.rm("dist", { recursive: true, force: true }),
-    fs6.rm("public", { recursive: true, force: true })
+    fs7.rm("dist", { recursive: true, force: true }),
+    fs7.rm("public", { recursive: true, force: true })
   ]);
 }
 function createRestartServerPlugin(serverProcess, onServerBuildComplete, hotReloadManager) {
   return {
     name: "restart-server",
-    setup(build) {
-      build.onEnd((result) => {
+    setup(build2) {
+      build2.onEnd((result) => {
         if (result.errors.length > 0) {
           console.error(
             `Server build failed with ${result.errors.length} error(s)`
@@ -3661,8 +3761,8 @@ async function startDevServer() {
           }),
           {
             name: "client-build-logger",
-            setup(build) {
-              build.onEnd((result) => {
+            setup(build2) {
+              build2.onEnd((result) => {
                 if (result.errors.length > 0) {
                   console.error(
                     `Client build failed with ${result.errors.length} error(s)`
@@ -3701,6 +3801,7 @@ async function startDevServer() {
     minify: config.build?.minify ?? false,
     plugins: [
       ...config.plugins?.map((cb) => cb(store)) || [],
+      ...config.server_plugins?.map((cb) => cb(store)) || [],
       useMyPlugin({
         isServerBuild: true,
         onClientFound: async (filePath) => {
@@ -3756,8 +3857,8 @@ __export(config_exports, {
 });
 
 // src/add/component/component.ts
-import * as fs7 from "fs";
-import * as path8 from "path";
+import * as fs8 from "fs";
+import * as path9 from "path";
 import * as ts2 from "typescript";
 var ComponentDefinition = class {
 };
@@ -3923,40 +4024,40 @@ Processing dependencies for "${name}": [${component.dependencies.join(
       addComponent(dependency, processedComponents);
     }
   }
-  const componentModulePath = path8.join(
+  const componentModulePath = path9.join(
     process.cwd(),
     "src/component/component.module.ts"
   );
-  const componentPath = path8.join(
+  const componentPath = path9.join(
     process.cwd(),
     `src/component/component/${name}.component.tsx`
   );
-  const componentDir = path8.dirname(componentPath);
-  const appModulePath = path8.join(process.cwd(), "src/app/app.module.ts");
-  if (!fs7.existsSync(componentModulePath)) {
-    const moduleDir = path8.dirname(componentModulePath);
-    if (!fs7.existsSync(moduleDir)) {
-      fs7.mkdirSync(moduleDir, { recursive: true });
+  const componentDir = path9.dirname(componentPath);
+  const appModulePath = path9.join(process.cwd(), "src/app/app.module.ts");
+  if (!fs8.existsSync(componentModulePath)) {
+    const moduleDir = path9.dirname(componentModulePath);
+    if (!fs8.existsSync(moduleDir)) {
+      fs8.mkdirSync(moduleDir, { recursive: true });
     }
-    fs7.writeFileSync(componentModulePath, createModule(), "utf-8");
+    fs8.writeFileSync(componentModulePath, createModule(), "utf-8");
   }
-  if (!fs7.existsSync(componentDir)) {
-    fs7.mkdirSync(componentDir, { recursive: true });
+  if (!fs8.existsSync(componentDir)) {
+    fs8.mkdirSync(componentDir, { recursive: true });
   }
-  if (!fs7.existsSync(componentPath)) {
-    fs7.writeFileSync(componentPath, component.generate(), "utf-8");
+  if (!fs8.existsSync(componentPath)) {
+    fs8.writeFileSync(componentPath, component.generate(), "utf-8");
     console.log(`Created ${name}.component.tsx`);
   } else {
     console.log(`${name}.component.tsx already exists, skipping file creation`);
   }
-  const moduleContent = fs7.readFileSync(componentModulePath, "utf-8");
+  const moduleContent = fs8.readFileSync(componentModulePath, "utf-8");
   const updatedModule = updateModuleWithComponent(moduleContent, name);
-  fs7.writeFileSync(componentModulePath, updatedModule, "utf-8");
-  if (fs7.existsSync(appModulePath)) {
-    const appModuleContent = fs7.readFileSync(appModulePath, "utf-8");
+  fs8.writeFileSync(componentModulePath, updatedModule, "utf-8");
+  if (fs8.existsSync(appModulePath)) {
+    const appModuleContent = fs8.readFileSync(appModulePath, "utf-8");
     const updatedAppModule = ensureComponentModuleImported(appModuleContent);
     if (updatedAppModule !== appModuleContent) {
-      fs7.writeFileSync(appModulePath, updatedAppModule, "utf-8");
+      fs8.writeFileSync(appModulePath, updatedAppModule, "utf-8");
     }
   }
 }
@@ -4142,28 +4243,28 @@ function toPascalCase(str) {
 }
 
 // src/utils/create.ts
-import * as fs8 from "fs";
-import * as path9 from "path";
+import * as fs9 from "fs";
+import * as path10 from "path";
 function createStructure(basePath, entry) {
-  fs8.mkdirSync(basePath, { recursive: true });
+  fs9.mkdirSync(basePath, { recursive: true });
   entry.files?.forEach((file) => {
-    fs8.writeFileSync(path9.join(basePath, file.name), file.content);
+    fs9.writeFileSync(path10.join(basePath, file.name), file.content);
   });
   entry.dirs?.forEach((dir) => {
-    const dirPath = path9.join(basePath, dir.name || "");
+    const dirPath = path10.join(basePath, dir.name || "");
     createStructure(dirPath, dir);
   });
 }
 
 // src/add/new/index.ts
-import path11 from "path";
+import path12 from "path";
 
 // src/add/module/module.ts
-import * as path10 from "path";
-import * as fs9 from "fs";
+import * as path11 from "path";
+import * as fs10 from "fs";
 import * as ts3 from "typescript";
 function addFeature(name) {
-  const featureDir = path10.join(process.cwd(), "src", "features", name);
+  const featureDir = path11.join(process.cwd(), "src", "features", name);
   addModule(name, featureDir);
   updateFeaturesIndex(name);
   updateAppModule(name);
@@ -4215,7 +4316,7 @@ function addModule(name, baseDir, root) {
   createStructure(baseDir, structure);
 }
 function updateFeaturesIndex(featureName) {
-  const featuresIndexPath = path10.join(
+  const featuresIndexPath = path11.join(
     process.cwd(),
     "src",
     "features",
@@ -4223,8 +4324,8 @@ function updateFeaturesIndex(featureName) {
   );
   const moduleName = toPascalCase(featureName + "_Module");
   const importPath = `./${featureName}/${featureName}.module`;
-  if (fs9.existsSync(featuresIndexPath)) {
-    let content = fs9.readFileSync(featuresIndexPath, "utf-8");
+  if (fs10.existsSync(featuresIndexPath)) {
+    let content = fs10.readFileSync(featuresIndexPath, "utf-8");
     const sourceFile = ts3.createSourceFile(
       "index.ts",
       content,
@@ -4250,24 +4351,24 @@ function updateFeaturesIndex(featureName) {
     }
     const exportStatement = `export { ${moduleName} } from "${importPath}";
 `;
-    fs9.appendFileSync(featuresIndexPath, exportStatement);
+    fs10.appendFileSync(featuresIndexPath, exportStatement);
   } else {
-    const featuresDir = path10.dirname(featuresIndexPath);
-    if (!fs9.existsSync(featuresDir)) {
-      fs9.mkdirSync(featuresDir, { recursive: true });
+    const featuresDir = path11.dirname(featuresIndexPath);
+    if (!fs10.existsSync(featuresDir)) {
+      fs10.mkdirSync(featuresDir, { recursive: true });
     }
     const exportStatement = `export { ${moduleName} } from "${importPath}";
 `;
-    fs9.writeFileSync(featuresIndexPath, exportStatement, "utf-8");
+    fs10.writeFileSync(featuresIndexPath, exportStatement, "utf-8");
   }
 }
 function updateAppModule(featureName) {
-  const appModulePath = path10.join(process.cwd(), "src", "app", "app.module.ts");
-  if (!fs9.existsSync(appModulePath)) {
+  const appModulePath = path11.join(process.cwd(), "src", "app", "app.module.ts");
+  if (!fs10.existsSync(appModulePath)) {
     return;
   }
   const moduleName = toPascalCase(featureName + "_Module");
-  let content = fs9.readFileSync(appModulePath, "utf-8");
+  let content = fs10.readFileSync(appModulePath, "utf-8");
   const sourceFile = ts3.createSourceFile(
     "app.module.ts",
     content,
@@ -4291,7 +4392,7 @@ function updateAppModule(featureName) {
   });
   if (hasImport) {
     content = addToModuleImportsArray(content, sourceFile, moduleName);
-    fs9.writeFileSync(appModulePath, content, "utf-8");
+    fs10.writeFileSync(appModulePath, content, "utf-8");
     return;
   }
   let lastImportEnd = 0;
@@ -4310,7 +4411,7 @@ function updateAppModule(featureName) {
     true
   );
   content = addToModuleImportsArray(content, newSourceFile, moduleName);
-  fs9.writeFileSync(appModulePath, content, "utf-8");
+  fs10.writeFileSync(appModulePath, content, "utf-8");
 }
 function addToModuleImportsArray(content, sourceFile, moduleName) {
   let decoratorNode;
@@ -4637,7 +4738,7 @@ export class ${componentName} {
 
 // src/add/new/index.ts
 function addNew(name) {
-  const baseDir = path11.join(process.cwd(), name);
+  const baseDir = path12.join(process.cwd(), name);
   const structure = {
     files: [
       { name: "package.json", content: genPackageJson(name) },
@@ -4664,7 +4765,7 @@ function addNew(name) {
     ]
   };
   createStructure(baseDir, structure);
-  const appDir = path11.join(process.cwd(), name, "src", "app");
+  const appDir = path12.join(process.cwd(), name, "src", "app");
   addModule("app", appDir, true);
   process.chdir(baseDir);
   addComponent("button");
@@ -4817,10 +4918,10 @@ bootstrap();
 }
 
 // src/add/ts/index.ts
-import path12 from "path";
+import path13 from "path";
 import prompts from "prompts";
 async function addTs(name) {
-  const baseDir = path12.join(process.cwd(), name);
+  const baseDir = path13.join(process.cwd(), name);
   const response = await prompts({
     type: "select",
     name: "target",
@@ -5198,21 +5299,21 @@ console.log('Running in Node.js environment');
 }
 
 // src/main.ts
-import path15 from "path";
-import { execSync } from "child_process";
+import path16 from "path";
+import { execSync as execSync2 } from "child_process";
 
 // src/docker/docker.ts
-import fs10 from "fs-extra";
-import path13 from "path";
+import fs11 from "fs-extra";
+import path14 from "path";
 import prompts2 from "prompts";
 import yaml from "js-yaml";
 async function dockerize(env = "prod") {
   const cwd = process.cwd();
-  const packageJsonPath = path13.join(cwd, "package.json");
-  if (!fs10.existsSync(packageJsonPath)) {
+  const packageJsonPath = path14.join(cwd, "package.json");
+  if (!fs11.existsSync(packageJsonPath)) {
     throw new Error("package.json not found. Are you in a Pod project?");
   }
-  const packageJson = await fs10.readJSON(packageJsonPath);
+  const packageJson = await fs11.readJSON(packageJsonPath);
   const projectName = packageJson.name;
   const detectedServices = detectServices(packageJson);
   const selectedServices = await selectServices(detectedServices);
@@ -5252,31 +5353,31 @@ async function selectServices(detected) {
   return detected.filter((s) => response.services.includes(s.name));
 }
 async function restructureProject(cwd, projectName) {
-  const nestedDir = path13.join(cwd, projectName);
-  if (fs10.existsSync(nestedDir)) {
+  const nestedDir = path14.join(cwd, projectName);
+  if (fs11.existsSync(nestedDir)) {
     console.log("\u26A0\uFE0F  Project already restructured, skipping...");
     return;
   }
-  await fs10.ensureDir(nestedDir);
-  const items = await fs10.readdir(cwd);
+  await fs11.ensureDir(nestedDir);
+  const items = await fs11.readdir(cwd);
   const toMove = items.filter((item) => item !== projectName);
   for (const item of toMove) {
-    const src = path13.join(cwd, item);
-    const dest = path13.join(nestedDir, item);
-    await fs10.move(src, dest, { overwrite: true });
+    const src = path14.join(cwd, item);
+    const dest = path14.join(nestedDir, item);
+    await fs11.move(src, dest, { overwrite: true });
   }
-  const envSrc = path13.join(nestedDir, ".env");
-  const envDest = path13.join(cwd, ".env");
-  if (fs10.existsSync(envSrc)) {
-    await fs10.move(envSrc, envDest, { overwrite: true });
+  const envSrc = path14.join(nestedDir, ".env");
+  const envDest = path14.join(cwd, ".env");
+  if (fs11.existsSync(envSrc)) {
+    await fs11.move(envSrc, envDest, { overwrite: true });
   }
 }
 async function writeEnvVars(cwd, services, env) {
-  const envPath = path13.join(cwd, ".env");
+  const envPath = path14.join(cwd, ".env");
   let existingEnv = {};
   let existingContent = "";
-  if (fs10.existsSync(envPath)) {
-    existingContent = await fs10.readFile(envPath, "utf8");
+  if (fs11.existsSync(envPath)) {
+    existingContent = await fs11.readFile(envPath, "utf8");
     existingEnv = parseEnvFile(existingContent);
   }
   const newVars = [];
@@ -5305,7 +5406,7 @@ async function writeEnvVars(cwd, services, env) {
   if (newVars.length > 0) {
     const separator = existingContent && !existingContent.endsWith("\n") ? "\n" : "";
     const newContent = existingContent + separator + (existingContent ? "\n" : "") + newVars.join("\n") + "\n";
-    await fs10.writeFile(envPath, newContent);
+    await fs11.writeFile(envPath, newContent);
     console.log(
       `\u2705 Added ${newVars.length} new environment variable(s) to .env`
     );
@@ -5329,8 +5430,8 @@ function parseEnvFile(content) {
   return env;
 }
 async function createDockerfile(cwd, projectName) {
-  const dockerfilePath = path13.join(cwd, projectName, "Dockerfile");
-  const dockerignorePath = path13.join(cwd, projectName, ".dockerignore");
+  const dockerfilePath = path14.join(cwd, projectName, "Dockerfile");
+  const dockerignorePath = path14.join(cwd, projectName, ".dockerignore");
   const dockerfile = `FROM node:18-alpine
 
 WORKDIR /app
@@ -5401,8 +5502,8 @@ docker-compose*.yml
 tmp
 temp
 `;
-  await fs10.writeFile(dockerfilePath, dockerfile);
-  await fs10.writeFile(dockerignorePath, dockerignore);
+  await fs11.writeFile(dockerfilePath, dockerfile);
+  await fs11.writeFile(dockerignorePath, dockerignore);
 }
 async function createDeployfile(cwd, projectName) {
   const deployFile = `name: ${projectName}
@@ -5520,8 +5621,8 @@ targets:
             find *backup_path -name "backup-*.tar.gz" -mtime +7 -delete
             docker image prune -af --filter "until=24h"
 `;
-  const deployFilePath = path13.join(cwd, "pod.deploy.yml");
-  await fs10.writeFile(deployFilePath, deployFile);
+  const deployFilePath = path14.join(cwd, "pod.deploy.yml");
+  await fs11.writeFile(deployFilePath, deployFile);
 }
 async function setupProduction(cwd, projectName, services) {
   const compose = {
@@ -5591,17 +5692,17 @@ async function setupProduction(cwd, projectName, services) {
     }
     compose.services[projectName].depends_on.push(service.name);
   }
-  const composePath = path13.join(cwd, "docker-compose.yml");
-  await fs10.writeFile(
+  const composePath = path14.join(cwd, "docker-compose.yml");
+  await fs11.writeFile(
     composePath,
     yaml.dump(compose, { indent: 2, lineWidth: -1 })
   );
 }
 async function setupDevelopment(cwd, projectName, services) {
-  const existingCompose = path13.join(cwd, "docker-compose.yml");
+  const existingCompose = path14.join(cwd, "docker-compose.yml");
   let existingServices = [];
-  if (fs10.existsSync(existingCompose)) {
-    const content = await fs10.readFile(existingCompose, "utf8");
+  if (fs11.existsSync(existingCompose)) {
+    const content = await fs11.readFile(existingCompose, "utf8");
     const existing = yaml.load(content);
     if (existing.services) {
       existingServices = Object.keys(existing.services).filter((s) => ["postgres", "mysql", "redis", "mongodb"].includes(s)).map((name) => ({ name }));
@@ -5670,15 +5771,15 @@ async function setupDevelopment(cwd, projectName, services) {
     };
     compose.services[projectName].depends_on.push(tunnelName);
   }
-  const devComposePath = path13.join(cwd, "docker-compose.dev.yml");
-  await fs10.writeFile(
+  const devComposePath = path14.join(cwd, "docker-compose.dev.yml");
+  await fs11.writeFile(
     devComposePath,
     yaml.dump(compose, { indent: 2, lineWidth: -1 })
   );
 }
 async function createTunnelService(projectDir, serviceName) {
-  const tunnelDir = path13.join(projectDir, `${serviceName}-tunnel`);
-  await fs10.ensureDir(tunnelDir);
+  const tunnelDir = path14.join(projectDir, `${serviceName}-tunnel`);
+  await fs11.ensureDir(tunnelDir);
   const dockerfile = `FROM alpine:latest
 
 RUN apk add --no-cache openssh-client
@@ -5706,8 +5807,8 @@ ssh -i $SSH_KEY \\
     -o ServerAliveInterval=60 \\
     $REMOTE_HOST
 `;
-  await fs10.writeFile(path13.join(tunnelDir, "Dockerfile"), dockerfile);
-  await fs10.writeFile(path13.join(tunnelDir, "tunnel.sh"), tunnelScript);
+  await fs11.writeFile(path14.join(tunnelDir, "Dockerfile"), dockerfile);
+  await fs11.writeFile(path14.join(tunnelDir, "tunnel.sh"), tunnelScript);
 }
 function getServiceConfig(serviceName) {
   const configs = {
@@ -5817,9 +5918,9 @@ function printNextSteps(projectName, env, services) {
 }
 
 // src/deploy/deploy.ts
-import fs11 from "fs-extra";
+import fs12 from "fs-extra";
 import yaml2 from "js-yaml";
-import path14 from "path";
+import path15 from "path";
 import os from "os";
 import { NodeSSH } from "node-ssh";
 import chalk from "chalk";
@@ -5850,7 +5951,7 @@ function deepInterpolate(obj, context2) {
 }
 function expandTilde(fp) {
   if (!fp || typeof fp !== "string") return fp;
-  return fp.startsWith("~/") ? path14.join(os.homedir(), fp.slice(2)) : fp;
+  return fp.startsWith("~/") ? path15.join(os.homedir(), fp.slice(2)) : fp;
 }
 function resolveLocalPaths(obj, cwd) {
   if (Array.isArray(obj)) {
@@ -5862,7 +5963,7 @@ function resolveLocalPaths(obj, cwd) {
       const isLocalPathKey = key === "keyPath" || key === "source";
       if (isLocalPathKey && typeof value === "string") {
         const expanded = expandTilde(value);
-        result[key] = path14.isAbsolute(expanded) ? expanded : path14.resolve(cwd, expanded);
+        result[key] = path15.isAbsolute(expanded) ? expanded : path15.resolve(cwd, expanded);
       } else {
         result[key] = resolveLocalPaths(value, cwd);
       }
@@ -6045,7 +6146,7 @@ var SSHStrategy = class {
     const trimmed = cmd.trim();
     if (trimmed.startsWith("cd ")) {
       const newPath = trimmed.replace("cd ", "").trim();
-      this.currentDir = path14.posix.resolve(this.currentDir, newPath);
+      this.currentDir = path15.posix.resolve(this.currentDir, newPath);
       if (!silent) console.log(chalk.gray(` [SSH Path: ${this.currentDir}]`));
       return { stdout: "", stderr: "", code: 0 };
     }
@@ -6073,13 +6174,13 @@ STDERR: ${result.stderr}`);
     }
   }
   async uploadContent(remotePath, content) {
-    const localTmp = path14.join(os.tmpdir(), `pod_tmp_${Date.now()}`);
-    fs11.writeFileSync(localTmp, content);
+    const localTmp = path15.join(os.tmpdir(), `pod_tmp_${Date.now()}`);
+    fs12.writeFileSync(localTmp, content);
     try {
       await this.ssh.execCommand(`mkdir -p $(dirname ${remotePath})`);
       await this.ssh.putFile(localTmp, remotePath);
     } finally {
-      if (fs11.existsSync(localTmp)) fs11.unlinkSync(localTmp);
+      if (fs12.existsSync(localTmp)) fs12.unlinkSync(localTmp);
     }
   }
   async readJson(remotePath) {
@@ -6094,7 +6195,7 @@ STDERR: ${result.stderr}`);
     const putOptions = { recursive: true, concurrency: 10 };
     if (exclude?.length) {
       putOptions.validate = (filePath) => {
-        const relative = path14.relative(source, filePath);
+        const relative = path15.relative(source, filePath);
         if (relative === "") return true;
         return !exclude.some((pattern) => {
           if (pattern.endsWith("/")) {
@@ -6126,7 +6227,7 @@ var LocalStrategy = class {
     const trimmed = cmd.trim();
     if (trimmed.startsWith("cd ")) {
       const newPath = trimmed.replace("cd ", "").trim();
-      this.currentDir = path14.resolve(this.currentDir, newPath);
+      this.currentDir = path15.resolve(this.currentDir, newPath);
       if (!silent) console.log(chalk.gray(` [Local Path: ${this.currentDir}]`));
       return { stdout: "", stderr: "", code: 0 };
     }
@@ -6149,29 +6250,29 @@ STDERR: ${err.stderr || err.message}`
   }
   async runScript(name, content, context2) {
     const interpolated = interpolate(content, context2);
-    const scriptPath = path14.join(
+    const scriptPath = path15.join(
       os.tmpdir(),
       `pod_script_${name}_${Date.now()}.sh`
     );
-    fs11.writeFileSync(scriptPath, interpolated);
-    fs11.chmodSync(scriptPath, "755");
+    fs12.writeFileSync(scriptPath, interpolated);
+    fs12.chmodSync(scriptPath, "755");
     try {
       await this.runCommand(scriptPath);
     } finally {
-      if (fs11.existsSync(scriptPath)) fs11.unlinkSync(scriptPath);
+      if (fs12.existsSync(scriptPath)) fs12.unlinkSync(scriptPath);
     }
   }
   async uploadContent(localPath, content) {
-    const dir = path14.dirname(localPath);
-    if (!fs11.existsSync(dir)) {
-      fs11.mkdirSync(dir, { recursive: true });
+    const dir = path15.dirname(localPath);
+    if (!fs12.existsSync(dir)) {
+      fs12.mkdirSync(dir, { recursive: true });
     }
-    fs11.writeFileSync(localPath, content);
+    fs12.writeFileSync(localPath, content);
   }
   async readJson(localPath) {
     try {
-      if (!fs11.existsSync(localPath)) return null;
-      const content = fs11.readFileSync(localPath, "utf8");
+      if (!fs12.existsSync(localPath)) return null;
+      const content = fs12.readFileSync(localPath, "utf8");
       return JSON.parse(content);
     } catch {
       return null;
@@ -6179,8 +6280,8 @@ STDERR: ${err.stderr || err.message}`
   }
   async syncDirectory(source, destination, exclude) {
     console.log(chalk.gray(` Copying ${source} \u2192 ${destination}`));
-    if (!fs11.existsSync(destination)) {
-      fs11.mkdirSync(destination, { recursive: true });
+    if (!fs12.existsSync(destination)) {
+      fs12.mkdirSync(destination, { recursive: true });
     }
     const shouldExclude = (relativePath) => {
       if (!exclude?.length) return false;
@@ -6197,19 +6298,19 @@ STDERR: ${err.stderr || err.message}`
       });
     };
     const copyRecursive = (src, dest) => {
-      const entries = fs11.readdirSync(src, { withFileTypes: true });
+      const entries = fs12.readdirSync(src, { withFileTypes: true });
       for (const entry of entries) {
-        const srcPath = path14.join(src, entry.name);
-        const destPath = path14.join(dest, entry.name);
-        const relativePath = path14.relative(source, srcPath);
+        const srcPath = path15.join(src, entry.name);
+        const destPath = path15.join(dest, entry.name);
+        const relativePath = path15.relative(source, srcPath);
         if (shouldExclude(relativePath)) continue;
         if (entry.isDirectory()) {
-          if (!fs11.existsSync(destPath)) {
-            fs11.mkdirSync(destPath, { recursive: true });
+          if (!fs12.existsSync(destPath)) {
+            fs12.mkdirSync(destPath, { recursive: true });
           }
           copyRecursive(srcPath, destPath);
         } else {
-          fs11.copyFileSync(srcPath, destPath);
+          fs12.copyFileSync(srcPath, destPath);
         }
       }
     };
@@ -6372,7 +6473,7 @@ var OperationHandler = class {
 async function deploy(targetName, options) {
   const cwd = process.cwd();
   const rawConfig = yaml2.load(
-    fs11.readFileSync(path14.join(cwd, "pod.deploy.yml"), "utf8"),
+    fs12.readFileSync(path15.join(cwd, "pod.deploy.yml"), "utf8"),
     { schema: yaml2.DEFAULT_SCHEMA }
   );
   const rawTarget = rawConfig.targets?.[targetName];
@@ -6392,7 +6493,7 @@ Pod Deploy: ${rawConfig.name} v${rawConfig.version} \u2192 ${targetName}
   const strategy = StrategyFactory.create(target, cwd);
   try {
     await strategy.connect();
-    const lockPath = target.deployPath ? path14.posix.join(target.deployPath, "pod-lock.json") : path14.join(cwd, "pod-lock.json");
+    const lockPath = target.deployPath ? path15.posix.join(target.deployPath, "pod-lock.json") : path15.join(cwd, "pod-lock.json");
     let lock = await strategy.readJson(lockPath) || {
       ensures: {},
       once_actions: []
@@ -6433,27 +6534,60 @@ Deployment Failed: ${err.message}`));
 
 // src/main.ts
 import chalk2 from "chalk";
+
+// src/compile/compile.ts
+import * as esbuild3 from "esbuild";
+import { execSync } from "child_process";
+async function compileFiles(entryPoints) {
+  const store = Store.getInstance();
+  const userConfig = await loadConfig();
+  const config = mergeConfig(getDefaultConfig(), userConfig);
+  await esbuild3.build({
+    entryPoints,
+    bundle: true,
+    outdir: config.build?.outDir || "dist",
+    platform: "node",
+    format: "esm",
+    packages: "external",
+    sourcemap: config.build?.sourcemap ?? true,
+    minify: config.build?.minify ?? false,
+    plugins: [
+      ...config.plugins?.map((cb) => cb(store)) || [],
+      useCompilePlugin({
+        decorators: config.build?.decorators ?? false
+      })
+    ],
+    write: true
+  });
+  if (config.build?.types) {
+    execSync("npx tsc", {
+      stdio: "inherit"
+    });
+  }
+}
+
+// src/main.ts
 var program = new Command();
-program.name("pod").description("Pod cli tool").version("1.0.31");
+program.name("pod").description("Pod cli tool").version("1.0.32");
 program.command("new <name> [type]").description("Start a new Orca Project").action(async (name, type) => {
   const orca = async () => {
     await addNew(name);
-    const appDir = path15.resolve(process.cwd());
+    const appDir = path16.resolve(process.cwd());
     const shell = process.platform === "win32" ? process.env.ComSpec || "cmd.exe" : "/bin/sh";
     console.log("Installing dependencies...");
-    execSync("npm install", { stdio: "inherit", cwd: appDir, shell });
+    execSync2("npm install", { stdio: "inherit", cwd: appDir, shell });
     console.log("Starting development server...");
-    execSync("npm run dev", { stdio: "inherit", cwd: appDir, shell });
+    execSync2("npm run dev", { stdio: "inherit", cwd: appDir, shell });
     console.log(
       `All done! Your app "${name}" is running in development mode.`
     );
   };
   const ts4 = async () => {
     await addTs(name);
-    const appDir = path15.resolve(process.cwd());
+    const appDir = path16.resolve(process.cwd());
     const shell = process.platform === "win32" ? process.env.ComSpec || "cmd.exe" : "/bin/sh";
     console.log("Installing dependencies...");
-    execSync("npm install", { stdio: "inherit", cwd: appDir, shell });
+    execSync2("npm install", { stdio: "inherit", cwd: appDir, shell });
   };
   switch (type) {
     case "orca":
@@ -6467,6 +6601,9 @@ program.command("new <name> [type]").description("Start a new Orca Project").act
 program.command("dev").description("Start Pod development server").action(async (opts) => {
   await startDevServer();
 });
+program.command("compile <files...>").description("Compile ts files with pod").action(async (files) => {
+  await compileFiles(files);
+});
 program.command("add <type> <name>").description("Add a component (c) or a feature (f)").action(async (type, name) => {
   try {
     if (type === "c") {
@@ -6503,6 +6640,7 @@ export {
   getDefaultConfig,
   getGlobalMacroGraph,
   loadConfig,
+  macroContext,
   macros_exports as macros,
   mergeConfig,
   plugins_exports as plugins,