@bayoudhi/moose-lib-serverless 0.7.1 → 0.7.3

package/dist/moose-runner.js

@@ -1,28 +1,28 @@
 #!/usr/bin/env node
 "use strict";
-var __create = Object.create;
-var __defProp = Object.defineProperty;
-var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
-var __getOwnPropNames = Object.getOwnPropertyNames;
-var __getProtoOf = Object.getPrototypeOf;
-var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __create2 = Object.create;
+var __defProp2 = Object.defineProperty;
+var __getOwnPropDesc2 = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames2 = Object.getOwnPropertyNames;
+var __getProtoOf2 = Object.getPrototypeOf;
+var __hasOwnProp2 = Object.prototype.hasOwnProperty;
 var __commonJS = (cb, mod) => function __require() {
-  return mod || (0, cb[__getOwnPropNames(cb)[0]])((mod = { exports: {} }).exports, mod), mod.exports;
+  return mod || (0, cb[__getOwnPropNames2(cb)[0]])((mod = { exports: {} }).exports, mod), mod.exports;
 };
-var __copyProps = (to, from, except, desc) => {
+var __copyProps2 = (to, from, except, desc) => {
   if (from && typeof from === "object" || typeof from === "function") {
-    for (let key of __getOwnPropNames(from))
-      if (!__hasOwnProp.call(to, key) && key !== except)
-        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+    for (let key of __getOwnPropNames2(from))
+      if (!__hasOwnProp2.call(to, key) && key !== except)
+        __defProp2(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc2(from, key)) || desc.enumerable });
   }
   return to;
 };
-var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+var __toESM2 = (mod, isNodeMode, target) => (target = mod != null ? __create2(__getProtoOf2(mod)) : {}, __copyProps2(
   // If the importer is in node compatibility mode or this is not an ESM
   // file that has been converted to a CommonJS file using a Babel-
   // compatible transform (i.e. "__esModule" has not been set), then set
   // "default" to the CommonJS "module.exports" for node compatibility.
-  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  isNodeMode || !mod || !mod.__esModule ? __defProp2(target, "default", { value: mod, enumerable: true }) : target,
   mod
 ));
 
@@ -261,118 +261,35 @@ var require_workflow = __commonJS({
 });
 
 // src/moose-runner.ts
-var __create2 = Object.create;
-var __defProp2 = Object.defineProperty;
-var __getOwnPropDesc2 = Object.getOwnPropertyDescriptor;
-var __getOwnPropNames2 = Object.getOwnPropertyNames;
-var __getProtoOf2 = Object.getPrototypeOf;
-var __hasOwnProp2 = Object.prototype.hasOwnProperty;
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
 var __esm = (fn, res) => function __init() {
-  return fn && (res = (0, fn[__getOwnPropNames2(fn)[0]])(fn = 0)), res;
+  return fn && (res = (0, fn[__getOwnPropNames(fn)[0]])(fn = 0)), res;
 };
 var __export = (target, all) => {
   for (var name in all)
-    __defProp2(target, name, { get: all[name], enumerable: true });
+    __defProp(target, name, { get: all[name], enumerable: true });
 };
-var __copyProps2 = (to, from, except, desc) => {
+var __copyProps = (to, from, except, desc) => {
   if (from && typeof from === "object" || typeof from === "function") {
-    for (let key of __getOwnPropNames2(from))
-      if (!__hasOwnProp2.call(to, key) && key !== except)
-        __defProp2(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc2(from, key)) || desc.enumerable });
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
   }
   return to;
 };
-var __toESM2 = (mod, isNodeMode, target) => (target = mod != null ? __create2(__getProtoOf2(mod)) : {}, __copyProps2(
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
   // If the importer is in node compatibility mode or this is not an ESM
   // file that has been converted to a CommonJS file using a Babel-
   // compatible transform (i.e. "__esModule" has not been set), then set
   // "default" to the CommonJS "module.exports" for node compatibility.
-  isNodeMode || !mod || !mod.__esModule ? __defProp2(target, "default", { value: mod, enumerable: true }) : target,
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
   mod
 ));
-function getSourceDir() {
-  return process.env.MOOSE_SOURCE_DIR || "app";
-}
-function hasCompiledArtifacts(projectRoot = process.cwd()) {
-  const sourceDir = getSourceDir();
-  const compiledIndexPath = import_path.default.join(
-    projectRoot,
-    ".moose",
-    "compiled",
-    sourceDir,
-    "index.js"
-  );
-  return (0, import_fs.existsSync)(compiledIndexPath);
-}
-function shouldUseCompiled(projectRoot = process.cwd()) {
-  const envSaysCompiled = process.env.MOOSE_USE_COMPILED === "true";
-  if (!envSaysCompiled) {
-    return false;
-  }
-  const hasArtifacts = hasCompiledArtifacts(projectRoot);
-  if (!hasArtifacts) {
-    console.warn(
-      `[moose] MOOSE_USE_COMPILED=true but no compiled artifacts found at .moose/compiled/${getSourceDir()}/index.js. Falling back to ts-node.`
-    );
-  }
-  return hasArtifacts;
-}
-function detectModuleSystem(projectRoot = process.cwd()) {
-  const pkgPath = import_path.default.join(projectRoot, "package.json");
-  if ((0, import_fs.existsSync)(pkgPath)) {
-    try {
-      const pkgContent = (0, import_fs.readFileSync)(pkgPath, "utf-8");
-      const pkg = JSON.parse(pkgContent);
-      if (pkg.type === "module") {
-        return "esm";
-      }
-    } catch (e) {
-      console.debug(
-        `[moose] Failed to parse package.json at ${pkgPath}, defaulting to CJS:`,
-        e
-      );
-    }
-  }
-  return "cjs";
-}
-async function loadModule(modulePath, projectRoot = process.cwd()) {
-  const moduleSystem = detectModuleSystem(projectRoot);
-  if (moduleSystem === "esm") {
-    const { pathToFileURL } = await import("url");
-    const fileUrl = pathToFileURL(modulePath).href;
-    return await import(fileUrl);
-  }
-  return require(modulePath);
-}
-var import_fs;
-var import_path;
-var MOOSE_COMPILER_PLUGINS;
-var COMMANDS_REQUIRING_PLUGINS;
-var init_compiler_config = __esm({
-  "src/compiler-config.ts"() {
-    "use strict";
-    import_fs = require("fs");
-    import_path = __toESM2(require("path"));
-    MOOSE_COMPILER_PLUGINS = [
-      {
-        transform: "./node_modules/@bayoudhi/moose-lib-serverless/dist/compilerPlugin.js"
-        // No longer using transformProgram - direct typia integration eliminates
-        // the need for program replacement and the associated incremental compilation issues
-      },
-      {
-        // Keep typia plugin for users who use typia directly (not through Moose resources)
-        transform: "typia/lib/transform"
-      }
-    ];
-    COMMANDS_REQUIRING_PLUGINS = [
-      "consumption-apis",
-      "consumption-type-serializer",
-      "dmv2-serializer",
-      "streaming-functions",
-      "scripts"
-    ];
-  }
-});
 var init_stackTrace = __esm({
   "src/dmv2/utils/stackTrace.ts"() {
     "use strict";
@@ -905,7 +822,7 @@ var init_helpers = __esm({
     import_client2 = require_client();
     import_node_crypto3 = require("crypto");
     import_perf_hooks = require("perf_hooks");
-    fs = __toESM2(require("fs"));
+    fs = __toESM(require("fs"));
     init_internal();
     init_sqlHelpers();
     MooseClient = class {
@@ -1102,8 +1019,8 @@ var ConfigError;
 var init_configFile = __esm({
   "src/config/configFile.ts"() {
     "use strict";
-    import_node_path = __toESM2(require("path"));
-    toml = __toESM2(require("toml"));
+    import_node_path = __toESM(require("path"));
+    toml = __toESM(require("toml"));
     ConfigError = class extends Error {
       constructor(message) {
         super(message);
@@ -1514,6 +1431,112 @@ var init_index = __esm({
     init_types();
   }
 });
+function getSourceDir() {
+  return process.env.MOOSE_SOURCE_DIR || "app";
+}
+function readUserOutDir(projectRoot = process.cwd()) {
+  try {
+    let content = (0, import_fs.readFileSync)(
+      import_path.default.join(projectRoot, "tsconfig.json"),
+      "utf-8"
+    );
+    if (content.charCodeAt(0) === 65279) {
+      content = content.slice(1);
+    }
+    const tsconfig = eval(`(${content})`);
+    return tsconfig.compilerOptions?.outDir || null;
+  } catch {
+    return null;
+  }
+}
+function getOutDir(projectRoot2 = process.cwd()) {
+  const userOutDir = readUserOutDir(projectRoot2);
+  return userOutDir || DEFAULT_OUT_DIR;
+}
+function getCompiledIndexPath(projectRoot2 = process.cwd()) {
+  const outDir = getOutDir(projectRoot2);
+  const sourceDir = getSourceDir();
+  return import_path.default.resolve(projectRoot2, outDir, sourceDir, "index.js");
+}
+function hasCompiledArtifacts(projectRoot2 = process.cwd()) {
+  return (0, import_fs.existsSync)(getCompiledIndexPath(projectRoot2));
+}
+function detectModuleSystem(projectRoot2 = process.cwd()) {
+  const pkgPath = import_path.default.join(projectRoot2, "package.json");
+  if ((0, import_fs.existsSync)(pkgPath)) {
+    try {
+      const pkgContent = (0, import_fs.readFileSync)(pkgPath, "utf-8");
+      const pkg = JSON.parse(pkgContent);
+      if (pkg.type === "module") {
+        return "esm";
+      }
+    } catch (e) {
+      console.debug(
+        `[moose] Failed to parse package.json at ${pkgPath}, defaulting to CJS:`,
+        e
+      );
+    }
+  }
+  return "cjs";
+}
+function getModuleOptions(moduleSystem) {
+  if (moduleSystem === "esm") {
+    return {
+      module: "ES2022",
+      moduleResolution: "bundler"
+    };
+  }
+  return {
+    module: "CommonJS",
+    moduleResolution: "Node"
+  };
+}
+async function loadModule(modulePath, projectRoot2 = process.cwd()) {
+  const moduleSystem = detectModuleSystem(projectRoot2);
+  if (moduleSystem === "esm") {
+    const { pathToFileURL } = await import("url");
+    const fileUrl = pathToFileURL(modulePath).href;
+    return await import(fileUrl);
+  }
+  return require(modulePath);
+}
+var import_fs;
+var import_path;
+var MOOSE_COMPILER_PLUGINS;
+var MOOSE_COMPILER_OPTIONS;
+var MOOSE_MODULE_OPTIONS;
+var DEFAULT_OUT_DIR;
+var init_compiler_config = __esm({
+  "src/compiler-config.ts"() {
+    "use strict";
+    import_fs = require("fs");
+    import_path = __toESM(require("path"));
+    MOOSE_COMPILER_PLUGINS = [
+      {
+        transform: "./node_modules/@bayoudhi/moose-lib-serverless/dist/compilerPlugin.js"
+        // No longer using transformProgram - direct typia integration eliminates
+        // the need for program replacement and the associated incremental compilation issues
+      },
+      {
+        // Keep typia plugin for users who use typia directly (not through Moose resources)
+        transform: "typia/lib/transform"
+      }
+    ];
+    MOOSE_COMPILER_OPTIONS = {
+      experimentalDecorators: true,
+      esModuleInterop: true,
+      // Disable strict module syntax checking to avoid dual-package type conflicts
+      // This prevents errors where the same type imported with different resolution
+      // modes (CJS vs ESM) is treated as incompatible
+      verbatimModuleSyntax: false
+    };
+    MOOSE_MODULE_OPTIONS = {
+      module: "NodeNext",
+      moduleResolution: "NodeNext"
+    };
+    DEFAULT_OUT_DIR = ".moose/compiled";
+  }
+});
 function findSourceFiles(dir, extensions = [".ts", ".tsx", ".js", ".jsx", ".mts", ".cts"]) {
   const files = [];
   try {
@@ -1539,13 +1562,23 @@ function findSourceFiles(dir, extensions = [".ts", ".tsx", ".js", ".jsx", ".mts"
   }
   return files;
 }
+function pathStem(filePath) {
+  const ext = path3.extname(filePath);
+  return ext ? filePath.slice(0, -ext.length) : filePath;
+}
 function findUnloadedFiles() {
-  const appDir = path3.resolve(import_process.default.cwd(), getSourceDir());
+  const cwd = import_process.default.cwd();
+  const sourceDir = getSourceDir();
+  const appDir = path3.resolve(cwd, sourceDir);
+  const compiledAppDir = path3.resolve(cwd, getOutDir(), sourceDir);
   const allSourceFiles = findSourceFiles(appDir);
-  const loadedFiles = new Set(
-    Object.keys(require.cache).filter((key) => key.startsWith(appDir)).map((key) => path3.resolve(key))
+  const loadedStems = new Set(
+    Object.keys(require.cache).filter((key) => key.startsWith(compiledAppDir)).map((key) => pathStem(path3.relative(compiledAppDir, key)))
   );
-  const unloadedFiles = allSourceFiles.map((file) => path3.resolve(file)).filter((file) => !loadedFiles.has(file)).map((file) => path3.relative(import_process.default.cwd(), file));
+  const unloadedFiles = allSourceFiles.filter((file) => {
+    const stem = pathStem(path3.relative(appDir, file));
+    return !loadedStems.has(stem);
+  }).map((file) => path3.relative(cwd, file));
   return unloadedFiles;
 }
 function isS3QueueConfig(config) {
@@ -1754,6 +1787,16 @@ function convertKafkaEngineConfig(config) {
     format: config.format
   };
 }
+function convertMergeEngineConfig(config) {
+  if (!("engine" in config) || config.engine !== "Merge") {
+    return void 0;
+  }
+  return {
+    engine: "Merge",
+    sourceDatabase: config.sourceDatabase,
+    tablesRegexp: config.tablesRegexp
+  };
+}
 function convertTableConfigToEngineConfig(config) {
   const engine = extractEngineValue(config);
   const basicConfig = convertBasicEngineConfig(engine, config);
@@ -1782,6 +1825,9 @@ function convertTableConfigToEngineConfig(config) {
   if (engine === "Kafka") {
     return convertKafkaEngineConfig(config);
   }
+  if (engine === "Merge") {
+    return convertMergeEngineConfig(config);
+  }
   return void 0;
 }
 function findTaskInTree(task, targetName) {
@@ -1815,9 +1861,9 @@ var getWebApps2;
 var init_internal = __esm({
   "src/dmv2/internal.ts"() {
     "use strict";
-    import_process = __toESM2(require("process"));
-    fs2 = __toESM2(require("fs"));
-    path3 = __toESM2(require("path"));
+    import_process = __toESM(require("process"));
+    fs2 = __toESM(require("fs"));
+    path3 = __toESM(require("path"));
     init_index();
     init_commons();
     init_compiler_config();
@@ -2064,7 +2110,8 @@ var init_internal = __esm({
           sourceTables: mv.sourceTables,
           targetTable: mv.targetTable.name,
           targetDatabase: mv.targetTable.config.database,
-          metadata: mv.metadata
+          metadata: mv.metadata,
+          lifeCycle: mv.lifeCycle
         };
       });
       registry.views.forEach((view) => {
@@ -2105,34 +2152,33 @@ var init_internal = __esm({
       );
     };
     loadIndex = async () => {
-      const useCompiled2 = shouldUseCompiled();
-      if (!useCompiled2) {
-        const registry = getMooseInternal();
-        registry.tables.clear();
-        registry.streams.clear();
-        registry.ingestApis.clear();
-        registry.apis.clear();
-        registry.sqlResources.clear();
-        registry.workflows.clear();
-        registry.webApps.clear();
-        registry.materializedViews.clear();
-        registry.views.clear();
-        const appDir = `${import_process.default.cwd()}/${getSourceDir()}`;
-        Object.keys(require.cache).forEach((key) => {
-          if (key.startsWith(appDir)) {
-            delete require.cache[key];
-          }
-        });
-      }
-      try {
+      if (!hasCompiledArtifacts()) {
+        const outDir2 = getOutDir();
         const sourceDir = getSourceDir();
-        if (useCompiled2) {
-          await loadModule(
-            `${import_process.default.cwd()}/.moose/compiled/${sourceDir}/index.js`
-          );
-        } else {
-          require(`${import_process.default.cwd()}/${sourceDir}/index.ts`);
+        throw new Error(
+          `Compiled artifacts not found at ${outDir2}/${sourceDir}/index.js. Run 'npx moose-tspc' to compile your TypeScript first.`
+        );
+      }
+      const registry = getMooseInternal();
+      registry.tables.clear();
+      registry.streams.clear();
+      registry.ingestApis.clear();
+      registry.apis.clear();
+      registry.sqlResources.clear();
+      registry.workflows.clear();
+      registry.webApps.clear();
+      registry.materializedViews.clear();
+      registry.views.clear();
+      const outDir = getOutDir();
+      const compiledDir = path3.isAbsolute(outDir) ? outDir : path3.join(import_process.default.cwd(), outDir);
+      Object.keys(require.cache).forEach((key) => {
+        if (key.startsWith(compiledDir)) {
+          delete require.cache[key];
         }
+      });
+      try {
+        const indexPath = getCompiledIndexPath();
+        await loadModule(indexPath);
       } catch (error) {
         let hint;
         let includeDetails = true;
@@ -2237,14 +2283,15 @@ var init_internal = __esm({
     };
   }
 });
-var import_ts_node = require("ts-node");
-init_compiler_config();
+var import_fs2 = require("fs");
+var import_path2 = require("path");
 init_internal();
-var import_http = __toESM2(require("http"));
+var import_http = __toESM(require("http"));
+var path4 = __toESM(require("path"));
 init_commons();
 init_helpers();
-var jose = __toESM2(require("jose"));
-var import_node_cluster = __toESM2(require("cluster"));
+var jose = __toESM(require("jose"));
+var import_node_cluster = __toESM(require("cluster"));
 var import_node_os = require("os");
 var import_node_process = require("process");
 var DEFAULT_MAX_CPU_USAGE_RATIO = 0.7;
@@ -2450,7 +2497,7 @@ var Cluster = class {
 init_sqlHelpers();
 init_internal();
 init_compiler_config();
-var util = __toESM2(require("util"));
+var util = __toESM(require("util"));
 var import_async_hooks = require("async_hooks");
 function setupStructuredConsole(getContextField, contextFieldName) {
   const contextStorage = new import_async_hooks.AsyncLocalStorage();
@@ -2573,9 +2620,8 @@ var toClientConfig2 = (config) => ({
   ...config,
   useSSL: config.useSSL ? "true" : "false"
 });
-var createPath = (apisDir, path5, useCompiled2) => {
-  const extension = useCompiled2 ? ".js" : ".ts";
-  return `${apisDir}${path5}${extension}`;
+var createPath = (apisDir, path6) => {
+  return `${apisDir}${path6}.js`;
 };
 var httpLogger = (req, res, startMs, apiName) => {
   const logFn = () => console.log(
@@ -2593,9 +2639,10 @@ var apiContextStorage = setupStructuredConsole(
   "api_name"
 );
 var apiHandler = async (publicKey, clickhouseClient, temporalClient, enforceAuth, jwtConfig) => {
-  const useCompiled2 = shouldUseCompiled();
   const sourceDir = getSourceDir();
-  const actualApisDir = useCompiled2 ? `${process.cwd()}/.moose/compiled/${sourceDir}/apis/` : void 0;
+  const outDir = getOutDir();
+  const outRoot = path4.isAbsolute(outDir) ? outDir : path4.join(process.cwd(), outDir);
+  const actualApisDir = path4.join(outRoot, sourceDir, "apis");
   const apis = await getApis2();
   return async (req, res) => {
     const start = Date.now();
@@ -2634,7 +2681,7 @@ var apiHandler = async (publicKey, clickhouseClient, temporalClient, enforceAuth
         httpLogger(req, res, start);
         return;
       }
-      const pathName = actualApisDir ? createPath(actualApisDir, fileName, useCompiled2) : fileName;
+      const pathName = createPath(actualApisDir, fileName);
       const paramsObject = Array.from(url.searchParams.entries()).reduce(
         (obj, [key, value]) => {
           const existingValue = obj[key];
@@ -2907,8 +2954,8 @@ var runApis = async (config) => {
 var import_node_stream2 = require("stream");
 var import_kafka_javascript2 = require_kafka_javascript();
 var import_node_buffer = require("buffer");
-var process3 = __toESM2(require("process"));
-var http2 = __toESM2(require("http"));
+var process3 = __toESM(require("process"));
+var http2 = __toESM(require("http"));
 init_commons();
 init_internal();
 init_json();
@@ -3459,42 +3506,20 @@ var runStreamingFunctions = async (args) => {
 };
 init_compiler_config();
 async function runExportSerializer(targetModel) {
-  const useCompiled2 = shouldUseCompiled();
   const sourceDir = getSourceDir();
+  const outDir = getOutDir();
   let modulePath = targetModel;
-  if (useCompiled2) {
-    const sourcePattern = `/${sourceDir}/`;
-    if (modulePath.includes(sourcePattern)) {
-      modulePath = modulePath.replace(
-        sourcePattern,
-        `/.moose/compiled/${sourceDir}/`
-      );
-    }
-    modulePath = modulePath.replace(/\.ts$/, ".js");
+  const sourcePattern = `/${sourceDir}/`;
+  if (modulePath.includes(sourcePattern)) {
+    modulePath = modulePath.replace(sourcePattern, `/${outDir}/${sourceDir}/`);
   }
+  modulePath = modulePath.replace(/\.ts$/, ".js");
   const exports_list = await loadModule(modulePath);
   console.log(JSON.stringify(exports_list));
 }
-var import_process2 = __toESM2(require("process"));
-init_compiler_config();
-async function runApiTypeSerializer(targetModel) {
-  const sourceDir = getSourceDir();
-  const useCompiled2 = shouldUseCompiled();
-  const apiPath = useCompiled2 ? `${import_process2.default.cwd()}/.moose/compiled/${sourceDir}/apis/${targetModel}.js` : `${import_process2.default.cwd()}/${sourceDir}/apis/${targetModel}.ts`;
-  const module2 = await loadModule(apiPath);
-  const func = module2.default;
-  const inputSchema = func["moose_input_schema"] || null;
-  const outputSchema = func["moose_output_schema"] || null;
-  console.log(
-    JSON.stringify({
-      inputSchema,
-      outputSchema
-    })
-  );
-}
 var import_worker2 = require_worker();
-var path4 = __toESM2(require("path"));
-var fs3 = __toESM2(require("fs"));
+var path5 = __toESM(require("path"));
+var fs3 = __toESM(require("fs"));
 init_internal();
 var import_activity = require_activity();
 var import_workflow3 = require_workflow();
@@ -3805,7 +3830,7 @@ async function registerWorkflows(logger2, config) {
       }
     };
     const workflowBundle = await (0, import_worker2.bundleWorkflowCode)({
-      workflowsPath: path4.resolve(__dirname, "scripts/workflow.js"),
+      workflowsPath: path5.resolve(__dirname, "scripts/workflow.js"),
       logger: silentLogger
     });
     const worker = await import_worker2.Worker.create({
@@ -3882,32 +3907,13 @@ async function runScripts(config) {
   }
   return worker;
 }
-var import_process3 = __toESM2(require("process"));
 var import_commander = require("commander");
-var useCompiled = shouldUseCompiled();
-if (!useCompiled) {
-  const command = import_process3.default.argv[2];
-  const needsPlugins = COMMANDS_REQUIRING_PLUGINS.includes(command);
-  if (needsPlugins) {
-    (0, import_ts_node.register)({
-      require: ["tsconfig-paths/register"],
-      esm: true,
-      experimentalTsImportSpecifiers: true,
-      compiler: "ts-patch/compiler",
-      compilerOptions: {
-        plugins: [...MOOSE_COMPILER_PLUGINS],
-        experimentalDecorators: true
-      }
-    });
-  } else {
-    (0, import_ts_node.register)({
-      esm: true,
-      experimentalTsImportSpecifiers: true
-    });
-  }
-}
+var packageJson = { version: "0.6.417" };
 var program = new import_commander.Command();
-program.name("moose-runner").description("Moose runner for various operations").version("1.0.0");
+program.name("moose-runner").description("Moose runner for various operations").version(packageJson.version);
+program.command("print-version").description("Print the installed moose-lib version").action(() => {
+  process.stdout.write(packageJson.version);
+});
 program.command("dmv2-serializer").description("Load DMv2 index").action(async () => {
   await dumpMooseInternal();
 });
@@ -3971,9 +3977,6 @@ program.command("streaming-functions").description("Run streaming functions").ar
     runStreamingFunctions(config);
   }
 );
-program.command("consumption-type-serializer").description("Run consumption type serializer").argument("<target-model>", "Target model to serialize").action(async (targetModel) => {
-  await runApiTypeSerializer(targetModel);
-});
 program.command("scripts").description("Run scripts").option("--temporal-url <url>", "Temporal server URL").option("--temporal-namespace <namespace>", "Temporal namespace").option("--client-cert <path>", "Path to client certificate").option("--client-key <path>", "Path to client key").option("--api-key <key>", "API key for authentication").action((options) => {
   runScripts({
     temporalConfig: options.temporalUrl ? {