@bayoudhi/moose-lib-serverless 0.5.0 → 0.7.0

package/dist/moose-runner.js

@@ -0,0 +1,3988 @@
+#!/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 __commonJS = (cb, mod) => function __require() {
+  return mod || (0, cb[__getOwnPropNames(cb)[0]])((mod = { exports: {} }).exports, mod), mod.exports;
+};
+var __copyProps = (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 });
+  }
+  return to;
+};
+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 ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+
+// stub-native:@514labs/kafka-javascript
+var require_kafka_javascript = __commonJS({
+  "stub-native:@514labs/kafka-javascript"(exports2, module2) {
+    "use strict";
+    function createDeepProxy() {
+      var handler = {
+        get: function(_, prop) {
+          if (prop === "__esModule") return true;
+          if (prop === "default") return proxy;
+          if (typeof prop === "symbol") return void 0;
+          return proxy;
+        },
+        apply: function() {
+          return proxy;
+        },
+        construct: function() {
+          return proxy;
+        },
+        ownKeys: function() {
+          return ["length", "name", "prototype"];
+        },
+        getOwnPropertyDescriptor: function(target, prop) {
+          if (prop === "length" || prop === "name" || prop === "prototype") {
+            return Object.getOwnPropertyDescriptor(target, prop);
+          }
+          return void 0;
+        },
+        getPrototypeOf: function() {
+          return proxy;
+        }
+      };
+      var proxy = new Proxy(function() {
+      }, handler);
+      return proxy;
+    }
+    module2.exports = createDeepProxy();
+  }
+});
+
+// stub-native:@temporalio/client
+var require_client = __commonJS({
+  "stub-native:@temporalio/client"(exports2, module2) {
+    "use strict";
+    function createDeepProxy() {
+      var handler = {
+        get: function(_, prop) {
+          if (prop === "__esModule") return true;
+          if (prop === "default") return proxy;
+          if (typeof prop === "symbol") return void 0;
+          return proxy;
+        },
+        apply: function() {
+          return proxy;
+        },
+        construct: function() {
+          return proxy;
+        },
+        ownKeys: function() {
+          return ["length", "name", "prototype"];
+        },
+        getOwnPropertyDescriptor: function(target, prop) {
+          if (prop === "length" || prop === "name" || prop === "prototype") {
+            return Object.getOwnPropertyDescriptor(target, prop);
+          }
+          return void 0;
+        },
+        getPrototypeOf: function() {
+          return proxy;
+        }
+      };
+      var proxy = new Proxy(function() {
+      }, handler);
+      return proxy;
+    }
+    module2.exports = createDeepProxy();
+  }
+});
+
+// stub-native:redis
+var require_redis = __commonJS({
+  "stub-native:redis"(exports2, module2) {
+    "use strict";
+    function createDeepProxy() {
+      var handler = {
+        get: function(_, prop) {
+          if (prop === "__esModule") return true;
+          if (prop === "default") return proxy;
+          if (typeof prop === "symbol") return void 0;
+          return proxy;
+        },
+        apply: function() {
+          return proxy;
+        },
+        construct: function() {
+          return proxy;
+        },
+        ownKeys: function() {
+          return ["length", "name", "prototype"];
+        },
+        getOwnPropertyDescriptor: function(target, prop) {
+          if (prop === "length" || prop === "name" || prop === "prototype") {
+            return Object.getOwnPropertyDescriptor(target, prop);
+          }
+          return void 0;
+        },
+        getPrototypeOf: function() {
+          return proxy;
+        }
+      };
+      var proxy = new Proxy(function() {
+      }, handler);
+      return proxy;
+    }
+    module2.exports = createDeepProxy();
+  }
+});
+
+// stub-native:@temporalio/worker
+var require_worker = __commonJS({
+  "stub-native:@temporalio/worker"(exports2, module2) {
+    "use strict";
+    function createDeepProxy() {
+      var handler = {
+        get: function(_, prop) {
+          if (prop === "__esModule") return true;
+          if (prop === "default") return proxy;
+          if (typeof prop === "symbol") return void 0;
+          return proxy;
+        },
+        apply: function() {
+          return proxy;
+        },
+        construct: function() {
+          return proxy;
+        },
+        ownKeys: function() {
+          return ["length", "name", "prototype"];
+        },
+        getOwnPropertyDescriptor: function(target, prop) {
+          if (prop === "length" || prop === "name" || prop === "prototype") {
+            return Object.getOwnPropertyDescriptor(target, prop);
+          }
+          return void 0;
+        },
+        getPrototypeOf: function() {
+          return proxy;
+        }
+      };
+      var proxy = new Proxy(function() {
+      }, handler);
+      return proxy;
+    }
+    module2.exports = createDeepProxy();
+  }
+});
+
+// stub-native:@temporalio/activity
+var require_activity = __commonJS({
+  "stub-native:@temporalio/activity"(exports2, module2) {
+    "use strict";
+    function createDeepProxy() {
+      var handler = {
+        get: function(_, prop) {
+          if (prop === "__esModule") return true;
+          if (prop === "default") return proxy;
+          if (typeof prop === "symbol") return void 0;
+          return proxy;
+        },
+        apply: function() {
+          return proxy;
+        },
+        construct: function() {
+          return proxy;
+        },
+        ownKeys: function() {
+          return ["length", "name", "prototype"];
+        },
+        getOwnPropertyDescriptor: function(target, prop) {
+          if (prop === "length" || prop === "name" || prop === "prototype") {
+            return Object.getOwnPropertyDescriptor(target, prop);
+          }
+          return void 0;
+        },
+        getPrototypeOf: function() {
+          return proxy;
+        }
+      };
+      var proxy = new Proxy(function() {
+      }, handler);
+      return proxy;
+    }
+    module2.exports = createDeepProxy();
+  }
+});
+
+// stub-native:@temporalio/workflow
+var require_workflow = __commonJS({
+  "stub-native:@temporalio/workflow"(exports2, module2) {
+    "use strict";
+    function createDeepProxy() {
+      var handler = {
+        get: function(_, prop) {
+          if (prop === "__esModule") return true;
+          if (prop === "default") return proxy;
+          if (typeof prop === "symbol") return void 0;
+          return proxy;
+        },
+        apply: function() {
+          return proxy;
+        },
+        construct: function() {
+          return proxy;
+        },
+        ownKeys: function() {
+          return ["length", "name", "prototype"];
+        },
+        getOwnPropertyDescriptor: function(target, prop) {
+          if (prop === "length" || prop === "name" || prop === "prototype") {
+            return Object.getOwnPropertyDescriptor(target, prop);
+          }
+          return void 0;
+        },
+        getPrototypeOf: function() {
+          return proxy;
+        }
+      };
+      var proxy = new Proxy(function() {
+      }, handler);
+      return proxy;
+    }
+    module2.exports = createDeepProxy();
+  }
+});
+
+// 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 __esm = (fn, res) => function __init() {
+  return fn && (res = (0, fn[__getOwnPropNames2(fn)[0]])(fn = 0)), res;
+};
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp2(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps2 = (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 });
+  }
+  return to;
+};
+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 ? __defProp2(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";
+  }
+});
+var init_typedBase = __esm({
+  "src/dmv2/typedBase.ts"() {
+    "use strict";
+    init_stackTrace();
+  }
+});
+var init_dataModelTypes = __esm({
+  "src/dataModels/dataModelTypes.ts"() {
+    "use strict";
+  }
+});
+var init_types = __esm({
+  "src/dataModels/types.ts"() {
+    "use strict";
+  }
+});
+function sqlImpl(strings, ...values) {
+  return new Sql(strings, values);
+}
+function createClickhouseParameter(parameterIndex, value) {
+  return `{p${parameterIndex}:${mapToClickHouseType(value)}}`;
+}
+function emptyIfUndefined(value) {
+  return value === void 0 ? "" : value;
+}
+var isTable;
+var isView;
+var isColumn;
+var sql;
+var instanceofSql;
+var Sql;
+var toQuery;
+var toQueryPreview;
+var getValueFromParameter;
+var mapToClickHouseType;
+var init_sqlHelpers = __esm({
+  "src/sqlHelpers.ts"() {
+    "use strict";
+    isTable = (value) => typeof value === "object" && value !== null && "kind" in value && value.kind === "OlapTable";
+    isView = (value) => typeof value === "object" && value !== null && "kind" in value && value.kind === "View";
+    isColumn = (value) => typeof value === "object" && value !== null && !("kind" in value) && "name" in value && "annotations" in value;
+    sql = sqlImpl;
+    instanceofSql = (value) => typeof value === "object" && "values" in value && "strings" in value;
+    Sql = class _Sql {
+      values;
+      strings;
+      constructor(rawStrings, rawValues) {
+        if (rawStrings.length - 1 !== rawValues.length) {
+          if (rawStrings.length === 0) {
+            throw new TypeError("Expected at least 1 string");
+          }
+          throw new TypeError(
+            `Expected ${rawStrings.length} strings to have ${rawStrings.length - 1} values`
+          );
+        }
+        const valuesLength = rawValues.reduce(
+          (len, value) => len + (instanceofSql(value) ? value.values.length : isColumn(value) || isTable(value) || isView(value) ? 0 : 1),
+          0
+        );
+        this.values = new Array(valuesLength);
+        this.strings = new Array(valuesLength + 1);
+        this.strings[0] = rawStrings[0];
+        let i = 0, pos = 0;
+        while (i < rawValues.length) {
+          const child = rawValues[i++];
+          const rawString = rawStrings[i];
+          if (instanceofSql(child)) {
+            this.strings[pos] += child.strings[0];
+            let childIndex = 0;
+            while (childIndex < child.values.length) {
+              this.values[pos++] = child.values[childIndex++];
+              this.strings[pos] = child.strings[childIndex];
+            }
+            this.strings[pos] += rawString;
+          } else if (isColumn(child)) {
+            const aggregationFunction = child.annotations.find(
+              ([k, _]) => k === "aggregationFunction"
+            );
+            if (aggregationFunction !== void 0) {
+              this.strings[pos] += `${aggregationFunction[1].functionName}Merge(\`${child.name}\`)`;
+            } else {
+              this.strings[pos] += `\`${child.name}\``;
+            }
+            this.strings[pos] += rawString;
+          } else if (isTable(child)) {
+            if (child.config.database) {
+              this.strings[pos] += `\`${child.config.database}\`.\`${child.name}\``;
+            } else {
+              this.strings[pos] += `\`${child.name}\``;
+            }
+            this.strings[pos] += rawString;
+          } else if (isView(child)) {
+            this.strings[pos] += `\`${child.name}\``;
+            this.strings[pos] += rawString;
+          } else {
+            this.values[pos++] = child;
+            this.strings[pos] = rawString;
+          }
+        }
+      }
+      /**
+       * Append another Sql fragment, returning a new Sql instance.
+       */
+      append(other) {
+        return new _Sql([...this.strings, ""], [...this.values, other]);
+      }
+    };
+    sql.join = function(fragments, separator) {
+      if (fragments.length === 0) return new Sql([""], []);
+      if (fragments.length === 1) return fragments[0];
+      const sep = separator ?? ", ";
+      const normalized = sep.includes(" ") ? sep : ` ${sep} `;
+      const strings = ["", ...Array(fragments.length - 1).fill(normalized), ""];
+      return new Sql(strings, fragments);
+    };
+    sql.raw = function(text) {
+      return new Sql([text], []);
+    };
+    toQuery = (sql3) => {
+      const parameterizedStubs = sql3.values.map(
+        (v, i) => createClickhouseParameter(i, v)
+      );
+      const query = sql3.strings.map(
+        (s, i) => s != "" ? `${s}${emptyIfUndefined(parameterizedStubs[i])}` : ""
+      ).join("");
+      const query_params = sql3.values.reduce(
+        (acc, v, i) => ({
+          ...acc,
+          [`p${i}`]: getValueFromParameter(v)
+        }),
+        {}
+      );
+      return [query, query_params];
+    };
+    toQueryPreview = (sql3) => {
+      try {
+        const formatValue = (v) => {
+          if (Array.isArray(v)) {
+            const [type, val] = v;
+            if (type === "Identifier") {
+              return `\`${String(val)}\``;
+            }
+            return `[${v.map((x) => formatValue(x)).join(", ")}]`;
+          }
+          if (v === null || v === void 0) return "NULL";
+          if (typeof v === "string") return `'${v.replace(/'/g, "''")}'`;
+          if (typeof v === "number") return String(v);
+          if (typeof v === "boolean") return v ? "true" : "false";
+          if (v instanceof Date)
+            return `'${v.toISOString().replace("T", " ").slice(0, 19)}'`;
+          try {
+            return JSON.stringify(v);
+          } catch {
+            return String(v);
+          }
+        };
+        let out = sql3.strings[0] ?? "";
+        for (let i = 0; i < sql3.values.length; i++) {
+          const val = getValueFromParameter(sql3.values[i]);
+          out += formatValue(val);
+          out += sql3.strings[i + 1] ?? "";
+        }
+        return out.replace(/\s+/g, " ").trim();
+      } catch (error) {
+        console.log(`toQueryPreview error: ${error}`);
+        return "/* query preview unavailable */";
+      }
+    };
+    getValueFromParameter = (value) => {
+      if (Array.isArray(value)) {
+        const [type, val] = value;
+        if (type === "Identifier") return val;
+      }
+      return value;
+    };
+    mapToClickHouseType = (value) => {
+      if (typeof value === "number") {
+        return Number.isInteger(value) ? "Int" : "Float";
+      }
+      if (typeof value === "boolean") return "Bool";
+      if (value instanceof Date) return "DateTime";
+      if (Array.isArray(value)) {
+        const [type, _] = value;
+        return type;
+      }
+      return "String";
+    };
+  }
+});
+var import_node_stream;
+var import_node_crypto;
+var init_olapTable = __esm({
+  "src/dmv2/sdk/olapTable.ts"() {
+    "use strict";
+    init_typedBase();
+    init_dataModelTypes();
+    init_types();
+    init_internal();
+    import_node_stream = require("stream");
+    import_node_crypto = require("crypto");
+    init_sqlHelpers();
+  }
+});
+var import_node_crypto2;
+var init_stream = __esm({
+  "src/dmv2/sdk/stream.ts"() {
+    "use strict";
+    init_typedBase();
+    init_internal();
+    import_node_crypto2 = require("crypto");
+    init_stackTrace();
+  }
+});
+var init_workflow = __esm({
+  "src/dmv2/sdk/workflow.ts"() {
+    "use strict";
+    init_internal();
+  }
+});
+var init_ingestApi = __esm({
+  "src/dmv2/sdk/ingestApi.ts"() {
+    "use strict";
+    init_typedBase();
+    init_internal();
+  }
+});
+var init_consumptionApi = __esm({
+  "src/dmv2/sdk/consumptionApi.ts"() {
+    "use strict";
+    init_typedBase();
+    init_internal();
+  }
+});
+var init_ingestPipeline = __esm({
+  "src/dmv2/sdk/ingestPipeline.ts"() {
+    "use strict";
+    init_typedBase();
+    init_stream();
+    init_olapTable();
+    init_ingestApi();
+    init_types();
+  }
+});
+var init_etlPipeline = __esm({
+  "src/dmv2/sdk/etlPipeline.ts"() {
+    "use strict";
+    init_workflow();
+  }
+});
+var init_materializedView = __esm({
+  "src/dmv2/sdk/materializedView.ts"() {
+    "use strict";
+    init_types();
+    init_sqlHelpers();
+    init_olapTable();
+    init_internal();
+    init_stackTrace();
+  }
+});
+var init_sqlResource = __esm({
+  "src/dmv2/sdk/sqlResource.ts"() {
+    "use strict";
+    init_internal();
+    init_sqlHelpers();
+    init_stackTrace();
+  }
+});
+var init_view = __esm({
+  "src/dmv2/sdk/view.ts"() {
+    "use strict";
+    init_sqlHelpers();
+    init_olapTable();
+    init_internal();
+    init_stackTrace();
+  }
+});
+var init_lifeCycle = __esm({
+  "src/dmv2/sdk/lifeCycle.ts"() {
+    "use strict";
+  }
+});
+var init_webApp = __esm({
+  "src/dmv2/sdk/webApp.ts"() {
+    "use strict";
+    init_internal();
+  }
+});
+var init_registry = __esm({
+  "src/dmv2/registry.ts"() {
+    "use strict";
+    init_internal();
+  }
+});
+var init_dmv2 = __esm({
+  "src/dmv2/index.ts"() {
+    "use strict";
+    init_olapTable();
+    init_types();
+    init_stream();
+    init_workflow();
+    init_ingestApi();
+    init_consumptionApi();
+    init_ingestPipeline();
+    init_etlPipeline();
+    init_materializedView();
+    init_sqlResource();
+    init_view();
+    init_lifeCycle();
+    init_webApp();
+    init_registry();
+  }
+});
+var init_browserCompatible = __esm({
+  "src/browserCompatible.ts"() {
+    "use strict";
+    init_dmv2();
+    init_types();
+    init_sqlHelpers();
+  }
+});
+function isTruthy(value) {
+  if (!value) return false;
+  switch (value.trim().toLowerCase()) {
+    case "1":
+    case "true":
+    case "yes":
+    case "on":
+      return true;
+    default:
+      return false;
+  }
+}
+function createProducerConfig(maxMessageBytes) {
+  return {
+    kafkaJS: {
+      idempotent: false,
+      // Not needed for at-least-once delivery
+      acks: ACKs,
+      retry: {
+        retries: MAX_RETRIES_PRODUCER,
+        maxRetryTime: MAX_RETRY_TIME_MS
+      }
+    },
+    "linger.ms": 0,
+    // This is to make sure at least once delivery with immediate feedback on the send
+    ...maxMessageBytes && { "message.max.bytes": maxMessageBytes }
+  };
+}
+var import_client;
+var import_kafka_javascript;
+var Kafka;
+var compilerLog;
+var getClickhouseClient;
+var cliLog;
+var MAX_RETRIES;
+var MAX_RETRY_TIME_MS;
+var RETRY_INITIAL_TIME_MS;
+var MAX_RETRIES_PRODUCER;
+var ACKs;
+var parseBrokerString;
+var logError;
+var buildSaslConfig;
+var getKafkaClient;
+var init_commons = __esm({
+  "src/commons.ts"() {
+    "use strict";
+    import_client = require("@clickhouse/client");
+    import_kafka_javascript = require_kafka_javascript();
+    ({ Kafka } = import_kafka_javascript.KafkaJS);
+    compilerLog = (message) => {
+      if (!isTruthy(process.env.MOOSE_DISABLE_COMPILER_LOGS)) {
+        console.log(message);
+      }
+    };
+    getClickhouseClient = ({
+      username,
+      password,
+      database,
+      useSSL,
+      host,
+      port
+    }) => {
+      const protocol = useSSL === "1" || useSSL.toLowerCase() === "true" ? "https" : "http";
+      console.log(`Connecting to Clickhouse at ${protocol}://${host}:${port}`);
+      return (0, import_client.createClient)({
+        url: `${protocol}://${host}:${port}`,
+        username,
+        password,
+        database,
+        application: "moose"
+        // Note: wait_end_of_query is configured per operation type, not globally
+        // to preserve SELECT query performance while ensuring INSERT/DDL reliability
+      });
+    };
+    cliLog = (log) => {
+      const level = log.message_type === "Error" ? "error" : log.message_type === "Warning" ? "warn" : "info";
+      const structuredLog = {
+        __moose_structured_log__: true,
+        level,
+        message: log.message,
+        resource_type: "runtime",
+        cli_action: log.action,
+        cli_message_type: log.message_type ?? "Info",
+        timestamp: (/* @__PURE__ */ new Date()).toISOString()
+      };
+      process.stderr.write(JSON.stringify(structuredLog) + "\n");
+    };
+    MAX_RETRIES = 150;
+    MAX_RETRY_TIME_MS = 1e3;
+    RETRY_INITIAL_TIME_MS = 100;
+    MAX_RETRIES_PRODUCER = 150;
+    ACKs = -1;
+    parseBrokerString = (brokerString) => brokerString.split(",").map((b) => b.trim()).filter((b) => b.length > 0);
+    logError = (logger2, e) => {
+      logger2.error(e.message);
+      const stack = e.stack;
+      if (stack) {
+        logger2.error(stack);
+      }
+    };
+    buildSaslConfig = (logger2, args) => {
+      const mechanism = args.saslMechanism ? args.saslMechanism.toLowerCase() : "";
+      switch (mechanism) {
+        case "plain":
+        case "scram-sha-256":
+        case "scram-sha-512":
+          return {
+            mechanism,
+            username: args.saslUsername || "",
+            password: args.saslPassword || ""
+          };
+        default:
+          logger2.warn(`Unsupported SASL mechanism: ${args.saslMechanism}`);
+          return void 0;
+      }
+    };
+    getKafkaClient = async (cfg, logger2) => {
+      const brokers = parseBrokerString(cfg.broker || "");
+      if (brokers.length === 0) {
+        throw new Error(`No valid broker addresses found in: "${cfg.broker}"`);
+      }
+      logger2.log(`Creating Kafka client with brokers: ${brokers.join(", ")}`);
+      logger2.log(`Security protocol: ${cfg.securityProtocol || "plaintext"}`);
+      logger2.log(`Client ID: ${cfg.clientId}`);
+      const saslConfig = buildSaslConfig(logger2, cfg);
+      return new Kafka({
+        kafkaJS: {
+          clientId: cfg.clientId,
+          brokers,
+          ssl: cfg.securityProtocol === "SASL_SSL",
+          ...saslConfig && { sasl: saslConfig },
+          retry: {
+            initialRetryTime: RETRY_INITIAL_TIME_MS,
+            maxRetryTime: MAX_RETRY_TIME_MS,
+            retries: MAX_RETRIES
+          }
+        }
+      });
+    };
+  }
+});
+var init_secrets = __esm({
+  "src/secrets.ts"() {
+    "use strict";
+  }
+});
+function formatElapsedTime(ms) {
+  if (ms < 1e3) {
+    return `${Math.round(ms)} ms`;
+  }
+  const seconds = ms / 1e3;
+  if (seconds < 60) {
+    return `${seconds.toFixed(2)} seconds`;
+  }
+  const minutes = Math.floor(seconds / 60);
+  const remainingSeconds = seconds % 60;
+  return `${minutes} minutes and ${remainingSeconds.toFixed(2)} seconds`;
+}
+async function getTemporalClient(temporalUrl, namespace, clientCert, clientKey, apiKey) {
+  try {
+    console.info(
+      `<api> Using temporal_url: ${temporalUrl} and namespace: ${namespace}`
+    );
+    let connectionOptions = {
+      address: temporalUrl,
+      connectTimeout: "3s"
+    };
+    if (clientCert && clientKey) {
+      console.log("Using TLS for secure Temporal");
+      const cert = await fs.readFileSync(clientCert);
+      const key = await fs.readFileSync(clientKey);
+      connectionOptions.tls = {
+        clientCertPair: { crt: cert, key }
+      };
+    } else if (apiKey) {
+      console.log("Using API key for secure Temporal");
+      connectionOptions.address = "us-west1.gcp.api.temporal.io:7233";
+      connectionOptions.apiKey = apiKey;
+      connectionOptions.tls = {};
+      connectionOptions.metadata = {
+        "temporal-namespace": namespace
+      };
+    }
+    console.log(`<api> Connecting to Temporal at ${connectionOptions.address}`);
+    const connection = await import_client2.Connection.connect(connectionOptions);
+    const client = new import_client2.Client({ connection, namespace });
+    console.log("<api> Connected to Temporal server");
+    return client;
+  } catch (error) {
+    console.warn(`Failed to connect to Temporal. Is the feature flag enabled?`);
+    console.warn(error);
+    return void 0;
+  }
+}
+var import_client2;
+var import_node_crypto3;
+var import_perf_hooks;
+var fs;
+var MooseClient;
+var QueryClient;
+var WorkflowClient;
+var init_helpers = __esm({
+  "src/consumption-apis/helpers.ts"() {
+    "use strict";
+    import_client2 = require_client();
+    import_node_crypto3 = require("crypto");
+    import_perf_hooks = require("perf_hooks");
+    fs = __toESM2(require("fs"));
+    init_internal();
+    init_sqlHelpers();
+    MooseClient = class {
+      query;
+      workflow;
+      constructor(queryClient, temporalClient) {
+        this.query = queryClient;
+        this.workflow = new WorkflowClient(temporalClient);
+      }
+    };
+    QueryClient = class {
+      client;
+      query_id_prefix;
+      constructor(client, query_id_prefix) {
+        this.client = client;
+        this.query_id_prefix = query_id_prefix;
+      }
+      async execute(sql3) {
+        const [query, query_params] = toQuery(sql3);
+        console.log(`[QueryClient] | Query: ${toQueryPreview(sql3)}`);
+        const start = import_perf_hooks.performance.now();
+        const result = await this.client.query({
+          query,
+          query_params,
+          format: "JSONEachRow",
+          query_id: this.query_id_prefix + (0, import_node_crypto3.randomUUID)()
+          // Note: wait_end_of_query deliberately NOT set here as this is used for SELECT queries
+          // where response buffering would harm streaming performance and concurrency
+        });
+        const elapsedMs = import_perf_hooks.performance.now() - start;
+        console.log(
+          `[QueryClient] | Query completed: ${formatElapsedTime(elapsedMs)}`
+        );
+        return result;
+      }
+      async command(sql3) {
+        const [query, query_params] = toQuery(sql3);
+        console.log(`[QueryClient] | Command: ${toQueryPreview(sql3)}`);
+        const start = import_perf_hooks.performance.now();
+        const result = await this.client.command({
+          query,
+          query_params,
+          query_id: this.query_id_prefix + (0, import_node_crypto3.randomUUID)()
+        });
+        const elapsedMs = import_perf_hooks.performance.now() - start;
+        console.log(
+          `[QueryClient] | Command completed: ${formatElapsedTime(elapsedMs)}`
+        );
+        return result;
+      }
+    };
+    WorkflowClient = class {
+      client;
+      constructor(temporalClient) {
+        this.client = temporalClient;
+      }
+      async execute(name, input_data) {
+        try {
+          if (!this.client) {
+            return {
+              status: 404,
+              body: `Temporal client not found. Is the feature flag enabled?`
+            };
+          }
+          const config = await this.getWorkflowConfig(name);
+          const [processedInput, workflowId] = this.processInputData(
+            name,
+            input_data
+          );
+          console.log(
+            `WorkflowClient - starting workflow: ${name} with config ${JSON.stringify(config)} and input_data ${JSON.stringify(processedInput)}`
+          );
+          const handle = await this.client.workflow.start("ScriptWorkflow", {
+            args: [
+              { workflow_name: name, execution_mode: "start" },
+              processedInput
+            ],
+            taskQueue: "typescript-script-queue",
+            workflowId,
+            workflowIdConflictPolicy: "FAIL",
+            workflowIdReusePolicy: "ALLOW_DUPLICATE",
+            retry: {
+              // Temporal's maximumAttempts = total attempts (initial + retries)
+              maximumAttempts: config.retries + 1
+            },
+            workflowRunTimeout: config.timeout
+          });
+          return {
+            status: 200,
+            body: `Workflow started: ${name}. View it in the Temporal dashboard: http://localhost:8080/namespaces/default/workflows/${workflowId}/${handle.firstExecutionRunId}/history`
+          };
+        } catch (error) {
+          return {
+            status: 400,
+            body: `Error starting workflow: ${error}`
+          };
+        }
+      }
+      async terminate(workflowId) {
+        try {
+          if (!this.client) {
+            return {
+              status: 404,
+              body: `Temporal client not found. Is the feature flag enabled?`
+            };
+          }
+          const handle = this.client.workflow.getHandle(workflowId);
+          await handle.terminate();
+          return {
+            status: 200,
+            body: `Workflow terminated: ${workflowId}`
+          };
+        } catch (error) {
+          return {
+            status: 400,
+            body: `Error terminating workflow: ${error}`
+          };
+        }
+      }
+      async getWorkflowConfig(name) {
+        const workflows = await getWorkflows2();
+        const workflow = workflows.get(name);
+        if (workflow) {
+          return {
+            retries: workflow.config.retries || 3,
+            timeout: workflow.config.timeout || "1h"
+          };
+        }
+        throw new Error(`Workflow config not found for ${name}`);
+      }
+      processInputData(name, input_data) {
+        let workflowId = name;
+        if (input_data) {
+          const hash = (0, import_node_crypto3.createHash)("sha256").update(JSON.stringify(input_data)).digest("hex").slice(0, 16);
+          workflowId = `${name}-${hash}`;
+        }
+        return [input_data, workflowId];
+      }
+    };
+  }
+});
+var init_webAppHelpers = __esm({
+  "src/consumption-apis/webAppHelpers.ts"() {
+    "use strict";
+  }
+});
+var init_task = __esm({
+  "src/scripts/task.ts"() {
+    "use strict";
+  }
+});
+var import_redis;
+var init_redisClient = __esm({
+  "src/clients/redisClient.ts"() {
+    "use strict";
+    import_redis = require_redis();
+  }
+});
+async function findConfigFile(startDir = process.cwd()) {
+  const fs4 = await import("fs");
+  let currentDir = import_node_path.default.resolve(startDir);
+  while (true) {
+    const configPath = import_node_path.default.join(currentDir, "moose.config.toml");
+    if (fs4.existsSync(configPath)) {
+      return configPath;
+    }
+    const parentDir = import_node_path.default.dirname(currentDir);
+    if (parentDir === currentDir) {
+      break;
+    }
+    currentDir = parentDir;
+  }
+  return null;
+}
+async function readProjectConfig() {
+  const fs4 = await import("fs");
+  const configPath = await findConfigFile();
+  if (!configPath) {
+    throw new ConfigError(
+      "moose.config.toml not found in current directory or any parent directory"
+    );
+  }
+  try {
+    const configContent = fs4.readFileSync(configPath, "utf-8");
+    const config = toml.parse(configContent);
+    return config;
+  } catch (error) {
+    throw new ConfigError(`Failed to parse moose.config.toml: ${error}`);
+  }
+}
+var import_node_path;
+var toml;
+var ConfigError;
+var init_configFile = __esm({
+  "src/config/configFile.ts"() {
+    "use strict";
+    import_node_path = __toESM2(require("path"));
+    toml = __toESM2(require("toml"));
+    ConfigError = class extends Error {
+      constructor(message) {
+        super(message);
+        this.name = "ConfigError";
+      }
+    };
+  }
+});
+var runtime_exports = {};
+var ConfigurationRegistry;
+var init_runtime = __esm({
+  "src/config/runtime.ts"() {
+    "use strict";
+    init_configFile();
+    ConfigurationRegistry = class _ConfigurationRegistry {
+      static instance;
+      clickhouseConfig;
+      kafkaConfig;
+      static getInstance() {
+        if (!_ConfigurationRegistry.instance) {
+          _ConfigurationRegistry.instance = new _ConfigurationRegistry();
+        }
+        return _ConfigurationRegistry.instance;
+      }
+      setClickHouseConfig(config) {
+        this.clickhouseConfig = config;
+      }
+      setKafkaConfig(config) {
+        this.kafkaConfig = config;
+      }
+      _env(name) {
+        const value = process.env[name];
+        if (value === void 0) return void 0;
+        const trimmed = value.trim();
+        return trimmed.length > 0 ? trimmed : void 0;
+      }
+      _parseBool(value) {
+        if (value === void 0) return void 0;
+        switch (value.trim().toLowerCase()) {
+          case "1":
+          case "true":
+          case "yes":
+          case "on":
+            return true;
+          case "0":
+          case "false":
+          case "no":
+          case "off":
+            return false;
+          default:
+            return void 0;
+        }
+      }
+      async getClickHouseConfig() {
+        if (this.clickhouseConfig) {
+          return this.clickhouseConfig;
+        }
+        const projectConfig = await readProjectConfig();
+        const envHost = this._env("MOOSE_CLICKHOUSE_CONFIG__HOST");
+        const envPort = this._env("MOOSE_CLICKHOUSE_CONFIG__HOST_PORT");
+        const envUser = this._env("MOOSE_CLICKHOUSE_CONFIG__USER");
+        const envPassword = this._env("MOOSE_CLICKHOUSE_CONFIG__PASSWORD");
+        const envDb = this._env("MOOSE_CLICKHOUSE_CONFIG__DB_NAME");
+        const envUseSSL = this._parseBool(
+          this._env("MOOSE_CLICKHOUSE_CONFIG__USE_SSL")
+        );
+        return {
+          host: envHost ?? projectConfig.clickhouse_config.host,
+          port: envPort ?? projectConfig.clickhouse_config.host_port.toString(),
+          username: envUser ?? projectConfig.clickhouse_config.user,
+          password: envPassword ?? projectConfig.clickhouse_config.password,
+          database: envDb ?? projectConfig.clickhouse_config.db_name,
+          useSSL: envUseSSL !== void 0 ? envUseSSL : projectConfig.clickhouse_config.use_ssl || false
+        };
+      }
+      async getStandaloneClickhouseConfig(overrides) {
+        if (this.clickhouseConfig) {
+          return { ...this.clickhouseConfig, ...overrides };
+        }
+        const envHost = this._env("MOOSE_CLICKHOUSE_CONFIG__HOST");
+        const envPort = this._env("MOOSE_CLICKHOUSE_CONFIG__HOST_PORT");
+        const envUser = this._env("MOOSE_CLICKHOUSE_CONFIG__USER");
+        const envPassword = this._env("MOOSE_CLICKHOUSE_CONFIG__PASSWORD");
+        const envDb = this._env("MOOSE_CLICKHOUSE_CONFIG__DB_NAME");
+        const envUseSSL = this._parseBool(
+          this._env("MOOSE_CLICKHOUSE_CONFIG__USE_SSL")
+        );
+        let projectConfig;
+        try {
+          projectConfig = await readProjectConfig();
+        } catch (error) {
+          projectConfig = null;
+        }
+        const defaults = {
+          host: "localhost",
+          port: "18123",
+          username: "default",
+          password: "",
+          database: "local",
+          useSSL: false
+        };
+        return {
+          host: overrides?.host ?? envHost ?? projectConfig?.clickhouse_config.host ?? defaults.host,
+          port: overrides?.port ?? envPort ?? projectConfig?.clickhouse_config.host_port.toString() ?? defaults.port,
+          username: overrides?.username ?? envUser ?? projectConfig?.clickhouse_config.user ?? defaults.username,
+          password: overrides?.password ?? envPassword ?? projectConfig?.clickhouse_config.password ?? defaults.password,
+          database: overrides?.database ?? envDb ?? projectConfig?.clickhouse_config.db_name ?? defaults.database,
+          useSSL: overrides?.useSSL ?? envUseSSL ?? projectConfig?.clickhouse_config.use_ssl ?? defaults.useSSL
+        };
+      }
+      async getKafkaConfig() {
+        if (this.kafkaConfig) {
+          return this.kafkaConfig;
+        }
+        const projectConfig = await readProjectConfig();
+        const envBroker = this._env("MOOSE_REDPANDA_CONFIG__BROKER") ?? this._env("MOOSE_KAFKA_CONFIG__BROKER");
+        const envMsgTimeout = this._env("MOOSE_REDPANDA_CONFIG__MESSAGE_TIMEOUT_MS") ?? this._env("MOOSE_KAFKA_CONFIG__MESSAGE_TIMEOUT_MS");
+        const envSaslUsername = this._env("MOOSE_REDPANDA_CONFIG__SASL_USERNAME") ?? this._env("MOOSE_KAFKA_CONFIG__SASL_USERNAME");
+        const envSaslPassword = this._env("MOOSE_REDPANDA_CONFIG__SASL_PASSWORD") ?? this._env("MOOSE_KAFKA_CONFIG__SASL_PASSWORD");
+        const envSaslMechanism = this._env("MOOSE_REDPANDA_CONFIG__SASL_MECHANISM") ?? this._env("MOOSE_KAFKA_CONFIG__SASL_MECHANISM");
+        const envSecurityProtocol = this._env("MOOSE_REDPANDA_CONFIG__SECURITY_PROTOCOL") ?? this._env("MOOSE_KAFKA_CONFIG__SECURITY_PROTOCOL");
+        const envNamespace = this._env("MOOSE_REDPANDA_CONFIG__NAMESPACE") ?? this._env("MOOSE_KAFKA_CONFIG__NAMESPACE");
+        const envSchemaRegistryUrl = this._env("MOOSE_REDPANDA_CONFIG__SCHEMA_REGISTRY_URL") ?? this._env("MOOSE_KAFKA_CONFIG__SCHEMA_REGISTRY_URL");
+        const fileKafka = projectConfig.kafka_config ?? projectConfig.redpanda_config;
+        return {
+          broker: envBroker ?? fileKafka?.broker ?? "localhost:19092",
+          messageTimeoutMs: envMsgTimeout ? parseInt(envMsgTimeout, 10) : fileKafka?.message_timeout_ms ?? 1e3,
+          saslUsername: envSaslUsername ?? fileKafka?.sasl_username,
+          saslPassword: envSaslPassword ?? fileKafka?.sasl_password,
+          saslMechanism: envSaslMechanism ?? fileKafka?.sasl_mechanism,
+          securityProtocol: envSecurityProtocol ?? fileKafka?.security_protocol,
+          namespace: envNamespace ?? fileKafka?.namespace,
+          schemaRegistryUrl: envSchemaRegistryUrl ?? fileKafka?.schema_registry_url
+        };
+      }
+      hasRuntimeConfig() {
+        return !!this.clickhouseConfig || !!this.kafkaConfig;
+      }
+    };
+    globalThis._mooseConfigRegistry = ConfigurationRegistry.getInstance();
+  }
+});
+var standalone_exports = {};
+__export(standalone_exports, {
+  getMooseClients: () => getMooseClients,
+  getMooseUtils: () => getMooseUtils
+});
+async function getMooseUtils(req) {
+  if (req !== void 0) {
+    console.warn(
+      "[DEPRECATED] getMooseUtils(req) no longer requires a request parameter. Use getMooseUtils() instead."
+    );
+  }
+  const runtimeContext = globalThis._mooseRuntimeContext;
+  if (runtimeContext) {
+    return {
+      client: runtimeContext.client,
+      sql,
+      jwt: runtimeContext.jwt
+    };
+  }
+  if (standaloneUtils) {
+    return standaloneUtils;
+  }
+  if (initPromise) {
+    return initPromise;
+  }
+  initPromise = (async () => {
+    await Promise.resolve().then(() => (init_runtime(), runtime_exports));
+    const configRegistry = globalThis._mooseConfigRegistry;
+    if (!configRegistry) {
+      throw new Error(
+        "Moose not initialized. Ensure you're running within a Moose app or have proper configuration set up."
+      );
+    }
+    const clickhouseConfig = await configRegistry.getStandaloneClickhouseConfig();
+    const clickhouseClient = getClickhouseClient(
+      toClientConfig(clickhouseConfig)
+    );
+    const queryClient = new QueryClient(clickhouseClient, "standalone");
+    const mooseClient = new MooseClient(queryClient);
+    standaloneUtils = {
+      client: mooseClient,
+      sql,
+      jwt: void 0
+    };
+    return standaloneUtils;
+  })();
+  try {
+    return await initPromise;
+  } finally {
+    initPromise = null;
+  }
+}
+async function getMooseClients(config) {
+  console.warn(
+    "[DEPRECATED] getMooseClients() is deprecated. Use getMooseUtils() instead."
+  );
+  if (config && Object.keys(config).length > 0) {
+    await Promise.resolve().then(() => (init_runtime(), runtime_exports));
+    const configRegistry = globalThis._mooseConfigRegistry;
+    if (!configRegistry) {
+      throw new Error(
+        "Configuration registry not initialized. Ensure the Moose framework is properly set up."
+      );
+    }
+    const clickhouseConfig = await configRegistry.getStandaloneClickhouseConfig(config);
+    const clickhouseClient = getClickhouseClient(
+      toClientConfig(clickhouseConfig)
+    );
+    const queryClient = new QueryClient(clickhouseClient, "standalone");
+    const mooseClient = new MooseClient(queryClient);
+    return { client: mooseClient };
+  }
+  const utils = await getMooseUtils();
+  return { client: utils.client };
+}
+var standaloneUtils;
+var initPromise;
+var toClientConfig;
+var init_standalone = __esm({
+  "src/consumption-apis/standalone.ts"() {
+    "use strict";
+    init_helpers();
+    init_commons();
+    init_sqlHelpers();
+    standaloneUtils = null;
+    initPromise = null;
+    toClientConfig = (config) => ({
+      ...config,
+      useSSL: config.useSSL ? "true" : "false"
+    });
+  }
+});
+function isNullableType(dt) {
+  return typeof dt === "object" && dt !== null && "nullable" in dt && typeof dt.nullable !== "undefined";
+}
+function isNestedType2(dt) {
+  return typeof dt === "object" && dt !== null && "columns" in dt && Array.isArray(dt.columns);
+}
+function isArrayType(dt) {
+  return typeof dt === "object" && dt !== null && "elementType" in dt && typeof dt.elementType !== "undefined";
+}
+function jsonDateReviver(key, value) {
+  const iso8601Format = /^([\+-]?\d{4}(?!\d{2}\b))((-?)((0[1-9]|1[0-2])(\3([12]\d|0[1-9]|3[01]))?|W([0-4]\d|5[0-2])(-?[1-7])?|(00[1-9]|0[1-9]\d|[12]\d{2}|3([0-5]\d|6[1-6])))([T\s]((([01]\d|2[0-3])((:?)[0-5]\d)?|24\:?00)([\.,]\d+(?!:))?)?(\17[0-5]\d([\.,]\d+)?)?([zZ]|([\+-])([01]\d|2[0-3]):?([0-5]\d)?)?)?)$/;
+  if (typeof value === "string" && iso8601Format.test(value)) {
+    return new Date(value);
+  }
+  return value;
+}
+function isDateType(dataType, annotations) {
+  if (annotations.some(
+    ([key, value]) => key === STRING_DATE_ANNOTATION && value === true
+  )) {
+    return false;
+  }
+  if (typeof dataType === "string") {
+    return dataType === "DateTime" || dataType.startsWith("DateTime(");
+  }
+  if (isNullableType(dataType)) {
+    return isDateType(dataType.nullable, annotations);
+  }
+  return false;
+}
+function buildFieldMutations(columns) {
+  const mutations = [];
+  for (const column of columns) {
+    const dataType = column.data_type;
+    if (isDateType(dataType, column.annotations)) {
+      mutations.push([column.name, ["parseDate"]]);
+      continue;
+    }
+    if (typeof dataType === "object" && dataType !== null) {
+      let unwrappedType = dataType;
+      if (isNullableType(dataType)) {
+        unwrappedType = dataType.nullable;
+      }
+      if (isNestedType2(unwrappedType)) {
+        const nestedMutations = buildFieldMutations(unwrappedType.columns);
+        if (nestedMutations.length > 0) {
+          mutations.push([column.name, nestedMutations]);
+        }
+        continue;
+      }
+      if (isArrayType(unwrappedType)) {
+        const elementType = unwrappedType.elementType;
+        if (isNestedType2(elementType)) {
+          const nestedMutations = buildFieldMutations(elementType.columns);
+          if (nestedMutations.length > 0) {
+            mutations.push([column.name, nestedMutations]);
+          }
+          continue;
+        }
+      }
+    }
+  }
+  return mutations;
+}
+function applyMutation(value, mutation) {
+  if (mutation === "parseDate") {
+    if (typeof value === "string") {
+      try {
+        const date = new Date(value);
+        return !isNaN(date.getTime()) ? date : value;
+      } catch {
+        return value;
+      }
+    }
+  }
+  return value;
+}
+function applyFieldMutations(obj, mutations) {
+  if (!obj || typeof obj !== "object") {
+    return;
+  }
+  for (const [fieldName, mutation] of mutations) {
+    if (!(fieldName in obj)) {
+      continue;
+    }
+    if (Array.isArray(mutation)) {
+      if (mutation.length > 0 && typeof mutation[0] === "string") {
+        const operations = mutation;
+        for (const operation of operations) {
+          obj[fieldName] = applyMutation(obj[fieldName], operation);
+        }
+      } else {
+        const nestedMutations = mutation;
+        const fieldValue = obj[fieldName];
+        if (Array.isArray(fieldValue)) {
+          for (const item of fieldValue) {
+            applyFieldMutations(item, nestedMutations);
+          }
+        } else if (fieldValue && typeof fieldValue === "object") {
+          applyFieldMutations(fieldValue, nestedMutations);
+        }
+      }
+    }
+  }
+}
+function buildFieldMutationsFromColumns(columns) {
+  if (!columns || columns.length === 0) {
+    return void 0;
+  }
+  const mutations = buildFieldMutations(columns);
+  return mutations.length > 0 ? mutations : void 0;
+}
+function mutateParsedJson(data, fieldMutations) {
+  if (!fieldMutations || !data) {
+    return;
+  }
+  applyFieldMutations(data, fieldMutations);
+}
+var STRING_DATE_ANNOTATION;
+var init_json = __esm({
+  "src/utilities/json.ts"() {
+    "use strict";
+    STRING_DATE_ANNOTATION = "stringDate";
+  }
+});
+var import_csv_parse;
+var CSV_DELIMITERS;
+var DEFAULT_CSV_CONFIG;
+var init_dataParser = __esm({
+  "src/utilities/dataParser.ts"() {
+    "use strict";
+    import_csv_parse = require("csv-parse");
+    init_json();
+    CSV_DELIMITERS = {
+      COMMA: ",",
+      TAB: "	",
+      SEMICOLON: ";",
+      PIPE: "|"
+    };
+    DEFAULT_CSV_CONFIG = {
+      delimiter: CSV_DELIMITERS.COMMA,
+      columns: true,
+      skipEmptyLines: true,
+      trim: true
+    };
+  }
+});
+var init_utilities = __esm({
+  "src/utilities/index.ts"() {
+    "use strict";
+    init_dataParser();
+  }
+});
+var init_dataSource = __esm({
+  "src/connectors/dataSource.ts"() {
+    "use strict";
+  }
+});
+var init_index = __esm({
+  "src/index.ts"() {
+    "use strict";
+    init_browserCompatible();
+    init_commons();
+    init_secrets();
+    init_helpers();
+    init_webAppHelpers();
+    init_task();
+    init_redisClient();
+    init_helpers();
+    init_standalone();
+    init_sqlHelpers();
+    init_utilities();
+    init_dataSource();
+    init_types();
+  }
+});
+function findSourceFiles(dir, extensions = [".ts", ".tsx", ".js", ".jsx", ".mts", ".cts"]) {
+  const files = [];
+  try {
+    const entries = fs2.readdirSync(dir, { withFileTypes: true });
+    for (const entry of entries) {
+      const fullPath = path3.join(dir, entry.name);
+      if (entry.isDirectory()) {
+        if (entry.name !== "node_modules" && !entry.name.startsWith(".")) {
+          files.push(...findSourceFiles(fullPath, extensions));
+        }
+      } else if (entry.isFile()) {
+        if (entry.name.endsWith(".d.ts") || entry.name.endsWith(".d.mts") || entry.name.endsWith(".d.cts")) {
+          continue;
+        }
+        const ext = path3.extname(entry.name);
+        if (extensions.includes(ext)) {
+          files.push(fullPath);
+        }
+      }
+    }
+  } catch (error) {
+    compilerLog(`Warning: Could not read directory ${dir}: ${error}`);
+  }
+  return files;
+}
+function findUnloadedFiles() {
+  const appDir = path3.resolve(import_process.default.cwd(), getSourceDir());
+  const allSourceFiles = findSourceFiles(appDir);
+  const loadedFiles = new Set(
+    Object.keys(require.cache).filter((key) => key.startsWith(appDir)).map((key) => path3.resolve(key))
+  );
+  const unloadedFiles = allSourceFiles.map((file) => path3.resolve(file)).filter((file) => !loadedFiles.has(file)).map((file) => path3.relative(import_process.default.cwd(), file));
+  return unloadedFiles;
+}
+function isS3QueueConfig(config) {
+  return "engine" in config && config.engine === "S3Queue";
+}
+function hasReplicatedEngine(config) {
+  if (!("engine" in config)) {
+    return false;
+  }
+  const engine = config.engine;
+  return engine === "ReplicatedMergeTree" || engine === "ReplicatedReplacingMergeTree" || engine === "ReplicatedAggregatingMergeTree" || engine === "ReplicatedSummingMergeTree" || engine === "ReplicatedCollapsingMergeTree" || engine === "ReplicatedVersionedCollapsingMergeTree";
+}
+function extractEngineValue(config) {
+  if (!("engine" in config)) {
+    return "MergeTree";
+  }
+  return config.engine;
+}
+function convertBasicEngineConfig(engine, config) {
+  switch (engine) {
+    case "MergeTree":
+      return { engine: "MergeTree" };
+    case "AggregatingMergeTree":
+      return { engine: "AggregatingMergeTree" };
+    case "ReplacingMergeTree": {
+      const replacingConfig = config;
+      return {
+        engine: "ReplacingMergeTree",
+        ver: replacingConfig.ver,
+        isDeleted: replacingConfig.isDeleted
+      };
+    }
+    case "SummingMergeTree": {
+      const summingConfig = config;
+      return {
+        engine: "SummingMergeTree",
+        columns: summingConfig.columns
+      };
+    }
+    case "CollapsingMergeTree": {
+      const collapsingConfig = config;
+      return {
+        engine: "CollapsingMergeTree",
+        sign: collapsingConfig.sign
+      };
+    }
+    case "VersionedCollapsingMergeTree": {
+      const versionedConfig = config;
+      return {
+        engine: "VersionedCollapsingMergeTree",
+        sign: versionedConfig.sign,
+        ver: versionedConfig.ver
+      };
+    }
+    default:
+      return void 0;
+  }
+}
+function convertReplicatedEngineConfig(engine, config) {
+  if (!hasReplicatedEngine(config)) {
+    return void 0;
+  }
+  switch (engine) {
+    case "ReplicatedMergeTree": {
+      const replicatedConfig = config;
+      return {
+        engine: "ReplicatedMergeTree",
+        keeperPath: replicatedConfig.keeperPath,
+        replicaName: replicatedConfig.replicaName
+      };
+    }
+    case "ReplicatedReplacingMergeTree": {
+      const replicatedConfig = config;
+      return {
+        engine: "ReplicatedReplacingMergeTree",
+        keeperPath: replicatedConfig.keeperPath,
+        replicaName: replicatedConfig.replicaName,
+        ver: replicatedConfig.ver,
+        isDeleted: replicatedConfig.isDeleted
+      };
+    }
+    case "ReplicatedAggregatingMergeTree": {
+      const replicatedConfig = config;
+      return {
+        engine: "ReplicatedAggregatingMergeTree",
+        keeperPath: replicatedConfig.keeperPath,
+        replicaName: replicatedConfig.replicaName
+      };
+    }
+    case "ReplicatedSummingMergeTree": {
+      const replicatedConfig = config;
+      return {
+        engine: "ReplicatedSummingMergeTree",
+        keeperPath: replicatedConfig.keeperPath,
+        replicaName: replicatedConfig.replicaName,
+        columns: replicatedConfig.columns
+      };
+    }
+    case "ReplicatedCollapsingMergeTree": {
+      const replicatedConfig = config;
+      return {
+        engine: "ReplicatedCollapsingMergeTree",
+        keeperPath: replicatedConfig.keeperPath,
+        replicaName: replicatedConfig.replicaName,
+        sign: replicatedConfig.sign
+      };
+    }
+    case "ReplicatedVersionedCollapsingMergeTree": {
+      const replicatedConfig = config;
+      return {
+        engine: "ReplicatedVersionedCollapsingMergeTree",
+        keeperPath: replicatedConfig.keeperPath,
+        replicaName: replicatedConfig.replicaName,
+        sign: replicatedConfig.sign,
+        ver: replicatedConfig.ver
+      };
+    }
+    default:
+      return void 0;
+  }
+}
+function convertS3QueueEngineConfig(config) {
+  if (!isS3QueueConfig(config)) {
+    return void 0;
+  }
+  return {
+    engine: "S3Queue",
+    s3Path: config.s3Path,
+    format: config.format,
+    awsAccessKeyId: config.awsAccessKeyId,
+    awsSecretAccessKey: config.awsSecretAccessKey,
+    compression: config.compression,
+    headers: config.headers
+  };
+}
+function convertS3EngineConfig(config) {
+  if (!("engine" in config) || config.engine !== "S3") {
+    return void 0;
+  }
+  return {
+    engine: "S3",
+    path: config.path,
+    format: config.format,
+    awsAccessKeyId: config.awsAccessKeyId,
+    awsSecretAccessKey: config.awsSecretAccessKey,
+    compression: config.compression,
+    partitionStrategy: config.partitionStrategy,
+    partitionColumnsInDataFile: config.partitionColumnsInDataFile
+  };
+}
+function convertBufferEngineConfig(config) {
+  if (!("engine" in config) || config.engine !== "Buffer") {
+    return void 0;
+  }
+  return {
+    engine: "Buffer",
+    targetDatabase: config.targetDatabase,
+    targetTable: config.targetTable,
+    numLayers: config.numLayers,
+    minTime: config.minTime,
+    maxTime: config.maxTime,
+    minRows: config.minRows,
+    maxRows: config.maxRows,
+    minBytes: config.minBytes,
+    maxBytes: config.maxBytes,
+    flushTime: config.flushTime,
+    flushRows: config.flushRows,
+    flushBytes: config.flushBytes
+  };
+}
+function convertDistributedEngineConfig(config) {
+  if (!("engine" in config) || config.engine !== "Distributed") {
+    return void 0;
+  }
+  return {
+    engine: "Distributed",
+    cluster: config.cluster,
+    targetDatabase: config.targetDatabase,
+    targetTable: config.targetTable,
+    shardingKey: config.shardingKey,
+    policyName: config.policyName
+  };
+}
+function convertIcebergS3EngineConfig(config) {
+  if (!("engine" in config) || config.engine !== "IcebergS3") {
+    return void 0;
+  }
+  return {
+    engine: "IcebergS3",
+    path: config.path,
+    format: config.format,
+    awsAccessKeyId: config.awsAccessKeyId,
+    awsSecretAccessKey: config.awsSecretAccessKey,
+    compression: config.compression
+  };
+}
+function convertKafkaEngineConfig(config) {
+  if (!("engine" in config) || config.engine !== "Kafka") {
+    return void 0;
+  }
+  return {
+    engine: "Kafka",
+    brokerList: config.brokerList,
+    topicList: config.topicList,
+    groupName: config.groupName,
+    format: config.format
+  };
+}
+function convertTableConfigToEngineConfig(config) {
+  const engine = extractEngineValue(config);
+  const basicConfig = convertBasicEngineConfig(engine, config);
+  if (basicConfig) {
+    return basicConfig;
+  }
+  const replicatedConfig = convertReplicatedEngineConfig(engine, config);
+  if (replicatedConfig) {
+    return replicatedConfig;
+  }
+  if (engine === "S3Queue") {
+    return convertS3QueueEngineConfig(config);
+  }
+  if (engine === "S3") {
+    return convertS3EngineConfig(config);
+  }
+  if (engine === "Buffer") {
+    return convertBufferEngineConfig(config);
+  }
+  if (engine === "Distributed") {
+    return convertDistributedEngineConfig(config);
+  }
+  if (engine === "IcebergS3") {
+    return convertIcebergS3EngineConfig(config);
+  }
+  if (engine === "Kafka") {
+    return convertKafkaEngineConfig(config);
+  }
+  return void 0;
+}
+function findTaskInTree(task, targetName) {
+  if (task.name === targetName) {
+    return task;
+  }
+  if (task.config.onComplete?.length) {
+    for (const childTask of task.config.onComplete) {
+      const found = findTaskInTree(childTask, targetName);
+      if (found) {
+        return found;
+      }
+    }
+  }
+  return void 0;
+}
+var import_process;
+var fs2;
+var path3;
+var moose_internal;
+var defaultRetentionPeriod;
+var toInfraMap;
+var getMooseInternal;
+var dumpMooseInternal;
+var loadIndex;
+var getStreamingFunctions;
+var getApis2;
+var getWorkflows2;
+var getTaskForWorkflow;
+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"));
+    init_index();
+    init_commons();
+    init_compiler_config();
+    moose_internal = {
+      tables: /* @__PURE__ */ new Map(),
+      streams: /* @__PURE__ */ new Map(),
+      ingestApis: /* @__PURE__ */ new Map(),
+      apis: /* @__PURE__ */ new Map(),
+      sqlResources: /* @__PURE__ */ new Map(),
+      workflows: /* @__PURE__ */ new Map(),
+      webApps: /* @__PURE__ */ new Map(),
+      materializedViews: /* @__PURE__ */ new Map(),
+      views: /* @__PURE__ */ new Map()
+    };
+    defaultRetentionPeriod = 60 * 60 * 24 * 7;
+    toInfraMap = (registry) => {
+      const tables = {};
+      const topics = {};
+      const ingestApis = {};
+      const apis = {};
+      const sqlResources = {};
+      const workflows = {};
+      const webApps = {};
+      const materializedViews = {};
+      const views = {};
+      registry.tables.forEach((table) => {
+        const id = table.config.version ? `${table.name}_${table.config.version}` : table.name;
+        let metadata = table.metadata;
+        if (!metadata && table.config && table.pipelineParent) {
+          metadata = table.pipelineParent.metadata;
+        }
+        const engineConfig = convertTableConfigToEngineConfig(table.config);
+        let tableSettings = void 0;
+        if (table.config.settings) {
+          tableSettings = Object.entries(table.config.settings).reduce(
+            (acc, [key, value]) => {
+              if (value !== void 0) {
+                acc[key] = String(value);
+              }
+              return acc;
+            },
+            {}
+          );
+        }
+        if (engineConfig?.engine === "S3Queue") {
+          if (!tableSettings) {
+            tableSettings = {};
+          }
+          if (!tableSettings.mode) {
+            tableSettings.mode = "unordered";
+          }
+        }
+        const hasOrderByFields = "orderByFields" in table.config && Array.isArray(table.config.orderByFields) && table.config.orderByFields.length > 0;
+        const hasOrderByExpression = "orderByExpression" in table.config && typeof table.config.orderByExpression === "string" && table.config.orderByExpression.length > 0;
+        if (hasOrderByFields && hasOrderByExpression) {
+          throw new Error(
+            `Table ${table.name}: Provide either orderByFields or orderByExpression, not both.`
+          );
+        }
+        const orderBy = hasOrderByExpression && "orderByExpression" in table.config ? table.config.orderByExpression ?? "" : "orderByFields" in table.config ? table.config.orderByFields ?? [] : [];
+        tables[id] = {
+          name: table.name,
+          columns: table.columnArray,
+          orderBy,
+          partitionBy: "partitionBy" in table.config ? table.config.partitionBy : void 0,
+          sampleByExpression: "sampleByExpression" in table.config ? table.config.sampleByExpression : void 0,
+          primaryKeyExpression: "primaryKeyExpression" in table.config ? table.config.primaryKeyExpression : void 0,
+          engineConfig,
+          version: table.config.version,
+          metadata,
+          lifeCycle: table.config.lifeCycle,
+          // Map 'settings' to 'tableSettings' for internal use
+          tableSettings: tableSettings && Object.keys(tableSettings).length > 0 ? tableSettings : void 0,
+          indexes: table.config.indexes?.map((i) => ({
+            ...i,
+            granularity: i.granularity === void 0 ? 1 : i.granularity,
+            arguments: i.arguments === void 0 ? [] : i.arguments
+          })) || [],
+          ttl: table.config.ttl,
+          database: table.config.database,
+          cluster: table.config.cluster
+        };
+      });
+      registry.streams.forEach((stream) => {
+        let metadata = stream.metadata;
+        if (!metadata && stream.config && stream.pipelineParent) {
+          metadata = stream.pipelineParent.metadata;
+        }
+        const transformationTargets = [];
+        const consumers = [];
+        stream._transformations.forEach((transforms, destinationName) => {
+          transforms.forEach(([destination, _, config]) => {
+            transformationTargets.push({
+              kind: "stream",
+              name: destinationName,
+              version: config.version,
+              metadata: config.metadata,
+              sourceFile: config.sourceFile
+            });
+          });
+        });
+        stream._consumers.forEach((consumer) => {
+          consumers.push({
+            version: consumer.config.version,
+            sourceFile: consumer.config.sourceFile
+          });
+        });
+        topics[stream.name] = {
+          name: stream.name,
+          columns: stream.columnArray,
+          targetTable: stream.config.destination?.name,
+          targetTableVersion: stream.config.destination?.config.version,
+          retentionPeriod: stream.config.retentionPeriod ?? defaultRetentionPeriod,
+          partitionCount: stream.config.parallelism ?? 1,
+          version: stream.config.version,
+          transformationTargets,
+          hasMultiTransform: stream._multipleTransformations === void 0,
+          consumers,
+          metadata,
+          lifeCycle: stream.config.lifeCycle,
+          schemaConfig: stream.config.schemaConfig
+        };
+      });
+      registry.ingestApis.forEach((api) => {
+        let metadata = api.metadata;
+        if (!metadata && api.config && api.pipelineParent) {
+          metadata = api.pipelineParent.metadata;
+        }
+        ingestApis[api.name] = {
+          name: api.name,
+          columns: api.columnArray,
+          version: api.config.version,
+          path: api.config.path,
+          writeTo: {
+            kind: "stream",
+            name: api.config.destination.name
+          },
+          deadLetterQueue: api.config.deadLetterQueue?.name,
+          metadata,
+          schema: api.schema,
+          allowExtraFields: api.allowExtraFields
+        };
+      });
+      registry.apis.forEach((api, key) => {
+        const rustKey = api.config.version ? `${api.name}:${api.config.version}` : api.name;
+        apis[rustKey] = {
+          name: api.name,
+          queryParams: api.columnArray,
+          responseSchema: api.responseSchema,
+          version: api.config.version,
+          path: api.config.path,
+          metadata: api.metadata
+        };
+      });
+      registry.sqlResources.forEach((sqlResource) => {
+        sqlResources[sqlResource.name] = {
+          name: sqlResource.name,
+          setup: sqlResource.setup,
+          teardown: sqlResource.teardown,
+          sourceFile: sqlResource.sourceFile,
+          sourceLine: sqlResource.sourceLine,
+          sourceColumn: sqlResource.sourceColumn,
+          pullsDataFrom: sqlResource.pullsDataFrom.map((r) => {
+            if (r.kind === "OlapTable") {
+              const table = r;
+              const id = table.config.version ? `${table.name}_${table.config.version}` : table.name;
+              return {
+                id,
+                kind: "Table"
+              };
+            } else if (r.kind === "SqlResource") {
+              const resource = r;
+              return {
+                id: resource.name,
+                kind: "SqlResource"
+              };
+            } else if (r.kind === "View") {
+              const view = r;
+              return {
+                id: view.name,
+                kind: "View"
+              };
+            } else if (r.kind === "MaterializedView") {
+              const mv = r;
+              return {
+                id: mv.name,
+                kind: "MaterializedView"
+              };
+            } else {
+              throw new Error(`Unknown sql resource dependency type: ${r}`);
+            }
+          }),
+          pushesDataTo: sqlResource.pushesDataTo.map((r) => {
+            if (r.kind === "OlapTable") {
+              const table = r;
+              const id = table.config.version ? `${table.name}_${table.config.version}` : table.name;
+              return {
+                id,
+                kind: "Table"
+              };
+            } else if (r.kind === "SqlResource") {
+              const resource = r;
+              return {
+                id: resource.name,
+                kind: "SqlResource"
+              };
+            } else if (r.kind === "View") {
+              const view = r;
+              return {
+                id: view.name,
+                kind: "View"
+              };
+            } else if (r.kind === "MaterializedView") {
+              const mv = r;
+              return {
+                id: mv.name,
+                kind: "MaterializedView"
+              };
+            } else {
+              throw new Error(`Unknown sql resource dependency type: ${r}`);
+            }
+          })
+        };
+      });
+      registry.workflows.forEach((workflow) => {
+        workflows[workflow.name] = {
+          name: workflow.name,
+          retries: workflow.config.retries,
+          timeout: workflow.config.timeout,
+          schedule: workflow.config.schedule
+        };
+      });
+      registry.webApps.forEach((webApp) => {
+        webApps[webApp.name] = {
+          name: webApp.name,
+          mountPath: webApp.config.mountPath || "/",
+          metadata: webApp.config.metadata
+        };
+      });
+      registry.materializedViews.forEach((mv) => {
+        materializedViews[mv.name] = {
+          name: mv.name,
+          selectSql: mv.selectSql,
+          sourceTables: mv.sourceTables,
+          targetTable: mv.targetTable.name,
+          targetDatabase: mv.targetTable.config.database,
+          metadata: mv.metadata
+        };
+      });
+      registry.views.forEach((view) => {
+        views[view.name] = {
+          name: view.name,
+          selectSql: view.selectSql,
+          sourceTables: view.sourceTables,
+          metadata: view.metadata
+        };
+      });
+      return {
+        topics,
+        tables,
+        ingestApis,
+        apis,
+        sqlResources,
+        workflows,
+        webApps,
+        materializedViews,
+        views,
+        unloadedFiles: []
+        // Will be populated by dumpMooseInternal
+      };
+    };
+    getMooseInternal = () => globalThis.moose_internal;
+    if (getMooseInternal() === void 0) {
+      globalThis.moose_internal = moose_internal;
+    }
+    dumpMooseInternal = async () => {
+      await loadIndex();
+      const infraMap = toInfraMap(getMooseInternal());
+      const unloadedFiles = findUnloadedFiles();
+      infraMap.unloadedFiles = unloadedFiles;
+      console.log(
+        "___MOOSE_STUFF___start",
+        JSON.stringify(infraMap),
+        "end___MOOSE_STUFF___"
+      );
+    };
+    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 {
+        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`);
+        }
+      } catch (error) {
+        let hint;
+        let includeDetails = true;
+        const details = error instanceof Error ? error.message : String(error);
+        if (details.includes("no transform has been configured") || details.includes("NoTransformConfigurationError")) {
+          hint = "\u{1F534} Typia Transformation Error\n\nThis is likely a bug in Moose. The Typia type transformer failed to process your code.\n\nPlease report this issue:\n  \u2022 Moose Slack: https://join.slack.com/t/moose-community/shared_invite/zt-2fjh5n3wz-cnOmM9Xe9DYAgQrNu8xKxg\n  \u2022 Include the stack trace below and the file being processed\n\n";
+          includeDetails = false;
+        } else if (details.includes("ERR_REQUIRE_ESM") || details.includes("ES Module")) {
+          hint = "The file or its dependencies are ESM-only. Switch to packages that dual-support CJS & ESM, or upgrade to Node 22.12+. If you must use Node 20, you may try Node 20.19\n\n";
+        }
+        if (hint === void 0) {
+          throw error;
+        } else {
+          const errorMsg = includeDetails ? `${hint}${details}` : hint;
+          const cause = error instanceof Error ? error : void 0;
+          throw new Error(errorMsg, { cause });
+        }
+      }
+    };
+    getStreamingFunctions = async () => {
+      await loadIndex();
+      const registry = getMooseInternal();
+      const transformFunctions = /* @__PURE__ */ new Map();
+      registry.streams.forEach((stream) => {
+        stream._transformations.forEach((transforms, destinationName) => {
+          transforms.forEach(([_, transform, config]) => {
+            const transformFunctionKey = `${stream.name}_${destinationName}${config.version ? `_${config.version}` : ""}`;
+            compilerLog(`getStreamingFunctions: ${transformFunctionKey}`);
+            transformFunctions.set(transformFunctionKey, [
+              transform,
+              config,
+              stream.columnArray
+            ]);
+          });
+        });
+        stream._consumers.forEach((consumer) => {
+          const consumerFunctionKey = `${stream.name}_<no-target>${consumer.config.version ? `_${consumer.config.version}` : ""}`;
+          transformFunctions.set(consumerFunctionKey, [
+            consumer.consumer,
+            consumer.config,
+            stream.columnArray
+          ]);
+        });
+      });
+      return transformFunctions;
+    };
+    getApis2 = async () => {
+      await loadIndex();
+      const apiFunctions = /* @__PURE__ */ new Map();
+      const registry = getMooseInternal();
+      const versionCountByName = /* @__PURE__ */ new Map();
+      const nameToSoleVersionHandler = /* @__PURE__ */ new Map();
+      registry.apis.forEach((api, key) => {
+        const handler = api.getHandler();
+        apiFunctions.set(key, handler);
+        if (!api.config.version) {
+          if (!apiFunctions.has(api.name)) {
+            apiFunctions.set(api.name, handler);
+          }
+          nameToSoleVersionHandler.delete(api.name);
+          versionCountByName.delete(api.name);
+        } else if (!apiFunctions.has(api.name)) {
+          const count = (versionCountByName.get(api.name) ?? 0) + 1;
+          versionCountByName.set(api.name, count);
+          if (count === 1) {
+            nameToSoleVersionHandler.set(api.name, handler);
+          } else {
+            nameToSoleVersionHandler.delete(api.name);
+          }
+        }
+      });
+      nameToSoleVersionHandler.forEach((handler, name) => {
+        if (!apiFunctions.has(name)) {
+          apiFunctions.set(name, handler);
+        }
+      });
+      return apiFunctions;
+    };
+    getWorkflows2 = async () => {
+      await loadIndex();
+      const registry = getMooseInternal();
+      return registry.workflows;
+    };
+    getTaskForWorkflow = async (workflowName, taskName) => {
+      const workflows = await getWorkflows2();
+      const workflow = workflows.get(workflowName);
+      if (!workflow) {
+        throw new Error(`Workflow ${workflowName} not found`);
+      }
+      const task = findTaskInTree(
+        workflow.config.startingTask,
+        taskName
+      );
+      if (!task) {
+        throw new Error(`Task ${taskName} not found in workflow ${workflowName}`);
+      }
+      return task;
+    };
+    getWebApps2 = async () => {
+      await loadIndex();
+      return getMooseInternal().webApps;
+    };
+  }
+});
+var import_ts_node = require("ts-node");
+init_compiler_config();
+init_internal();
+var import_http = __toESM2(require("http"));
+init_commons();
+init_helpers();
+var jose = __toESM2(require("jose"));
+var import_node_cluster = __toESM2(require("cluster"));
+var import_node_os = require("os");
+var import_node_process = require("process");
+var DEFAULT_MAX_CPU_USAGE_RATIO = 0.7;
+var RESTART_TIME_MS = 1e4;
+var SIGTERM = "SIGTERM";
+var SIGINT = "SIGINT";
+var SHUTDOWN_WORKERS_INTERVAL = 500;
+var Cluster = class {
+  // Tracks if shutdown is currently in progress
+  shutdownInProgress = false;
+  // Tracks if workers exited cleanly during shutdown
+  hasCleanWorkerExit = true;
+  // String identifying if this is primary or worker process
+  processStr = `${import_node_cluster.default.isPrimary ? "primary" : "worker"} process ${process.pid}`;
+  // Functions for starting and stopping workers
+  workerStart;
+  workerStop;
+  // Result from starting worker, needed for cleanup
+  startOutput;
+  maxCpuUsageRatio;
+  usedCpuCount;
+  /**
+   * Creates a new cluster manager instance.
+   *
+   * @param options - Configuration options for the cluster
+   * @param options.workerStart - Async function to execute when starting a worker
+   * @param options.workerStop - Async function to execute when stopping a worker
+   * @param options.maxCpuUsageRatio - Maximum ratio of CPU cores to utilize (0-1)
+   * @param options.maxWorkerCount - Maximum number of workers to spawn
+   * @throws {Error} If maxCpuUsageRatio is not between 0 and 1
+   */
+  constructor(options) {
+    this.workerStart = options.workerStart;
+    this.workerStop = options.workerStop;
+    if (options.maxCpuUsageRatio && (options.maxCpuUsageRatio > 1 || options.maxCpuUsageRatio < 0)) {
+      throw new Error("maxCpuUsageRatio must be between 0 and 1");
+    }
+    this.maxCpuUsageRatio = options.maxCpuUsageRatio || DEFAULT_MAX_CPU_USAGE_RATIO;
+    this.usedCpuCount = this.computeCPUUsageCount(
+      this.maxCpuUsageRatio,
+      options.maxWorkerCount
+    );
+  }
+  /**
+   * Calculates the number of CPU cores to utilize based on available parallelism and constraints.
+   *
+   * @param cpuUsageRatio - Ratio of CPU cores to use (0-1)
+   * @param maxWorkerCount - Optional maximum number of workers
+   * @returns The number of CPU cores to utilize
+   */
+  computeCPUUsageCount(cpuUsageRatio, maxWorkerCount) {
+    const cpuCount = (0, import_node_os.availableParallelism)();
+    const maxWorkers = maxWorkerCount || cpuCount;
+    return Math.min(
+      maxWorkers,
+      Math.max(1, Math.floor(cpuCount * cpuUsageRatio))
+    );
+  }
+  /**
+   * Initializes the cluster by spawning worker processes and setting up signal handlers.
+   * For the primary process, spawns workers and monitors parent process.
+   * For worker processes, executes the worker startup function.
+   *
+   * @throws {Error} If worker is undefined in worker process
+   */
+  async start() {
+    process.on(SIGTERM, this.gracefulClusterShutdown(SIGTERM));
+    process.on(SIGINT, this.gracefulClusterShutdown(SIGINT));
+    if (import_node_cluster.default.isPrimary) {
+      const parentPid = process.ppid;
+      setInterval(() => {
+        try {
+          process.kill(parentPid, 0);
+        } catch (e) {
+          console.log("Parent process has exited.");
+          this.gracefulClusterShutdown(SIGTERM)();
+        }
+      }, 1e3);
+      await this.bootWorkers(this.usedCpuCount);
+    } else {
+      if (!import_node_cluster.default.worker) {
+        throw new Error(
+          "Worker is not defined, it should be defined in worker process"
+        );
+      }
+      this.startOutput = await this.workerStart(
+        import_node_cluster.default.worker,
+        this.usedCpuCount
+      );
+    }
+  }
+  /**
+   * Spawns worker processes and configures their lifecycle event handlers.
+   * Handles worker online, exit and disconnect events.
+   * Automatically restarts failed workers during normal operation.
+   *
+   * @param numWorkers - Number of worker processes to spawn
+   */
+  bootWorkers = async (numWorkers) => {
+    console.info(`Setting ${numWorkers} workers...`);
+    for (let i = 0; i < numWorkers; i++) {
+      import_node_cluster.default.fork();
+    }
+    import_node_cluster.default.on("online", (worker) => {
+      console.info(`worker process ${worker.process.pid} is online`);
+    });
+    import_node_cluster.default.on("exit", (worker, code, signal) => {
+      console.info(
+        `worker ${worker.process.pid} exited with code ${code} and signal ${signal}`
+      );
+      if (!this.shutdownInProgress) {
+        setTimeout(() => import_node_cluster.default.fork(), RESTART_TIME_MS);
+      }
+      if (this.shutdownInProgress && code != 0) {
+        this.hasCleanWorkerExit = false;
+      }
+    });
+    import_node_cluster.default.on("disconnect", (worker) => {
+      console.info(`worker process ${worker.process.pid} has disconnected`);
+    });
+  };
+  /**
+   * Creates a handler function for graceful shutdown on receipt of a signal.
+   * Ensures only one shutdown can occur at a time.
+   * Handles shutdown differently for primary and worker processes.
+   *
+   * @param signal - The signal triggering the shutdown (e.g. SIGTERM)
+   * @returns An async function that performs the shutdown
+   */
+  gracefulClusterShutdown = (signal) => async () => {
+    if (this.shutdownInProgress) {
+      return;
+    }
+    this.shutdownInProgress = true;
+    this.hasCleanWorkerExit = true;
+    console.info(
+      `Got ${signal} on ${this.processStr}. Graceful shutdown start at ${(/* @__PURE__ */ new Date()).toISOString()}`
+    );
+    try {
+      if (import_node_cluster.default.isPrimary) {
+        await this.shutdownWorkers(signal);
+        console.info(`${this.processStr} - worker shutdown successful`);
+        (0, import_node_process.exit)(0);
+      } else {
+        if (this.startOutput) {
+          await this.workerStop(this.startOutput);
+        } else {
+          console.info(
+            `${this.processStr} - shutdown before worker fully started`
+          );
+        }
+        console.info(`${this.processStr} shutdown successful`);
+        this.hasCleanWorkerExit ? (0, import_node_process.exit)(0) : (0, import_node_process.exit)(1);
+      }
+    } catch (e) {
+      console.error(`${this.processStr} - shutdown failed`, e);
+      (0, import_node_process.exit)(1);
+    }
+  };
+  /**
+   * Gracefully terminates all worker processes.
+   * Monitors workers until they all exit or timeout occurs.
+   * Only relevant for the primary process.
+   *
+   * @param signal - The signal to send to worker processes
+   * @returns A promise that resolves when all workers have terminated
+   */
+  shutdownWorkers = (signal) => {
+    return new Promise((resolve3, reject) => {
+      if (!import_node_cluster.default.isPrimary) {
+        return resolve3();
+      }
+      if (!import_node_cluster.default.workers) {
+        return resolve3();
+      }
+      const workerIds = Object.keys(import_node_cluster.default.workers);
+      if (workerIds.length == 0) {
+        return resolve3();
+      }
+      let workersAlive = 0;
+      let funcRun = 0;
+      const cleanWorkers = () => {
+        ++funcRun;
+        workersAlive = 0;
+        Object.values(import_node_cluster.default.workers || {}).filter((worker) => !!worker).forEach((worker) => {
+          if (worker && !worker.isDead()) {
+            ++workersAlive;
+            if (funcRun == 1) {
+              worker.kill(signal);
+            }
+          }
+        });
+        console.info(workersAlive + " workers alive");
+        if (workersAlive == 0) {
+          clearInterval(interval);
+          return resolve3();
+        }
+      };
+      const interval = setInterval(cleanWorkers, SHUTDOWN_WORKERS_INTERVAL);
+    });
+  };
+};
+init_sqlHelpers();
+init_internal();
+init_compiler_config();
+var util = __toESM2(require("util"));
+var import_async_hooks = require("async_hooks");
+function setupStructuredConsole(getContextField, contextFieldName) {
+  const contextStorage = new import_async_hooks.AsyncLocalStorage();
+  const originalConsole = {
+    log: console.log,
+    info: console.info,
+    warn: console.warn,
+    error: console.error,
+    debug: console.debug
+  };
+  console.log = createStructuredConsoleWrapper(
+    contextStorage,
+    getContextField,
+    contextFieldName,
+    originalConsole.log,
+    "info"
+  );
+  console.info = createStructuredConsoleWrapper(
+    contextStorage,
+    getContextField,
+    contextFieldName,
+    originalConsole.info,
+    "info"
+  );
+  console.warn = createStructuredConsoleWrapper(
+    contextStorage,
+    getContextField,
+    contextFieldName,
+    originalConsole.warn,
+    "warn"
+  );
+  console.error = createStructuredConsoleWrapper(
+    contextStorage,
+    getContextField,
+    contextFieldName,
+    originalConsole.error,
+    "error"
+  );
+  console.debug = createStructuredConsoleWrapper(
+    contextStorage,
+    getContextField,
+    contextFieldName,
+    originalConsole.debug,
+    "debug"
+  );
+  return contextStorage;
+}
+function emitStructuredLog(contextStorage, getContextField, contextFieldName, level, message) {
+  const context = contextStorage.getStore();
+  if (!context) {
+    return false;
+  }
+  let ctxValue;
+  try {
+    ctxValue = getContextField(context);
+  } catch {
+    ctxValue = "unknown";
+  }
+  try {
+    process.stderr.write(
+      JSON.stringify({
+        __moose_structured_log__: true,
+        level,
+        message,
+        [contextFieldName]: ctxValue,
+        timestamp: (/* @__PURE__ */ new Date()).toISOString()
+      }) + "\n"
+    );
+    return true;
+  } catch {
+    return false;
+  }
+}
+function safeStringify(arg) {
+  if (typeof arg === "object" && arg !== null) {
+    if (arg instanceof Error) {
+      return util.inspect(arg, { depth: 2, breakLength: Infinity });
+    }
+    try {
+      return JSON.stringify(arg);
+    } catch (e) {
+      return util.inspect(arg, { depth: 2, breakLength: Infinity });
+    }
+  }
+  if (typeof arg === "string") {
+    return arg;
+  }
+  return util.inspect(arg);
+}
+function createStructuredConsoleWrapper(contextStorage, getContextField, contextFieldName, originalMethod, level) {
+  return (...args) => {
+    const context = contextStorage.getStore();
+    if (!context) {
+      originalMethod(...args);
+      return;
+    }
+    let ctxValue;
+    try {
+      ctxValue = getContextField(context);
+    } catch {
+      ctxValue = "unknown";
+    }
+    try {
+      const message = args.map((arg) => safeStringify(arg)).join(" ");
+      process.stderr.write(
+        JSON.stringify({
+          __moose_structured_log__: true,
+          level,
+          message,
+          [contextFieldName]: ctxValue,
+          timestamp: (/* @__PURE__ */ new Date()).toISOString()
+        }) + "\n"
+      );
+    } catch {
+      originalMethod(...args);
+    }
+  };
+}
+var toClientConfig2 = (config) => ({
+  ...config,
+  useSSL: config.useSSL ? "true" : "false"
+});
+var createPath = (apisDir, path5, useCompiled2) => {
+  const extension = useCompiled2 ? ".js" : ".ts";
+  return `${apisDir}${path5}${extension}`;
+};
+var httpLogger = (req, res, startMs, apiName) => {
+  const logFn = () => console.log(
+    `${req.method} ${req.url} ${res.statusCode} ${Date.now() - startMs}ms`
+  );
+  if (apiName) {
+    apiContextStorage.run({ apiName }, logFn);
+  } else {
+    logFn();
+  }
+};
+var modulesCache = /* @__PURE__ */ new Map();
+var apiContextStorage = setupStructuredConsole(
+  (ctx) => ctx.apiName,
+  "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 apis = await getApis2();
+  return async (req, res) => {
+    const start = Date.now();
+    let matchedApiName;
+    try {
+      const url = new URL(req.url || "", "http://localhost");
+      const fileName = url.pathname;
+      let jwtPayload;
+      if (publicKey && jwtConfig) {
+        const jwt = req.headers.authorization?.split(" ")[1];
+        if (jwt) {
+          try {
+            const { payload } = await jose.jwtVerify(jwt, publicKey, {
+              issuer: jwtConfig.issuer,
+              audience: jwtConfig.audience
+            });
+            jwtPayload = payload;
+          } catch (error) {
+            console.log("JWT verification failed");
+            if (enforceAuth) {
+              res.writeHead(401, { "Content-Type": "application/json" });
+              res.end(JSON.stringify({ error: "Unauthorized" }));
+              httpLogger(req, res, start);
+              return;
+            }
+          }
+        } else if (enforceAuth) {
+          res.writeHead(401, { "Content-Type": "application/json" });
+          res.end(JSON.stringify({ error: "Unauthorized" }));
+          httpLogger(req, res, start);
+          return;
+        }
+      } else if (enforceAuth) {
+        res.writeHead(401, { "Content-Type": "application/json" });
+        res.end(JSON.stringify({ error: "Unauthorized" }));
+        httpLogger(req, res, start);
+        return;
+      }
+      const pathName = actualApisDir ? createPath(actualApisDir, fileName, useCompiled2) : fileName;
+      const paramsObject = Array.from(url.searchParams.entries()).reduce(
+        (obj, [key, value]) => {
+          const existingValue = obj[key];
+          if (existingValue) {
+            if (Array.isArray(existingValue)) {
+              existingValue.push(value);
+            } else {
+              obj[key] = [existingValue, value];
+            }
+          } else {
+            obj[key] = value;
+          }
+          return obj;
+        },
+        {}
+      );
+      const versionParam = url.searchParams.get("version");
+      const cacheKey = versionParam ? `${pathName}:${versionParam}` : pathName;
+      let userFuncModule;
+      const cachedEntry = modulesCache.get(cacheKey);
+      if (cachedEntry !== void 0) {
+        userFuncModule = cachedEntry.module;
+        matchedApiName = cachedEntry.apiName;
+      } else {
+        let lookupName = fileName.replace(/^\/+|\/+$/g, "");
+        let version = null;
+        userFuncModule = apis.get(lookupName);
+        if (userFuncModule) {
+          matchedApiName = lookupName;
+        }
+        if (!userFuncModule) {
+          version = url.searchParams.get("version");
+          if (!version && lookupName.includes("/")) {
+            const pathParts = lookupName.split("/");
+            if (pathParts.length >= 2) {
+              lookupName = pathParts[0];
+              version = pathParts.slice(1).join("/");
+            }
+          }
+          if (!userFuncModule && version) {
+            const versionedKey = `${lookupName}:${version}`;
+            userFuncModule = apis.get(versionedKey);
+            if (userFuncModule) {
+              matchedApiName = lookupName;
+            }
+          }
+          if (!userFuncModule) {
+            userFuncModule = apis.get(lookupName);
+            if (userFuncModule) {
+              matchedApiName = lookupName;
+            }
+          }
+        }
+        if (!userFuncModule || matchedApiName === void 0) {
+          const availableApis = Array.from(apis.keys()).map(
+            (key) => key.replace(":", "/")
+          );
+          const errorMessage = version ? `API ${lookupName} with version ${version} not found. Available APIs: ${availableApis.join(", ")}` : `API ${lookupName} not found. Available APIs: ${availableApis.join(", ")}`;
+          throw new Error(errorMessage);
+        }
+        modulesCache.set(cacheKey, {
+          module: userFuncModule,
+          apiName: matchedApiName
+        });
+        apiContextStorage.run({ apiName: matchedApiName }, () => {
+          console.log(`[API] | Executing API: ${matchedApiName}`);
+        });
+      }
+      const queryClient = new QueryClient(clickhouseClient, fileName);
+      const apiName = matchedApiName;
+      const result = await apiContextStorage.run({ apiName }, async () => {
+        return await userFuncModule(paramsObject, {
+          client: new MooseClient(queryClient, temporalClient),
+          sql,
+          jwt: jwtPayload
+        });
+      });
+      let body;
+      let status;
+      if (Object.getPrototypeOf(result).constructor.name === "ResultSet") {
+        body = JSON.stringify(await result.json());
+      } else {
+        if ("body" in result && "status" in result) {
+          body = JSON.stringify(result.body);
+          status = result.status;
+        } else {
+          body = JSON.stringify(result);
+        }
+      }
+      if (status) {
+        res.writeHead(status, { "Content-Type": "application/json" });
+        httpLogger(req, res, start, apiName);
+      } else {
+        res.writeHead(200, { "Content-Type": "application/json" });
+        httpLogger(req, res, start, apiName);
+      }
+      res.end(body);
+    } catch (error) {
+      const logError2 = () => console.log("error in path ", req.url, error);
+      if (matchedApiName) {
+        apiContextStorage.run({ apiName: matchedApiName }, logError2);
+      } else {
+        logError2();
+      }
+      if (Object.getPrototypeOf(error).constructor.name === "TypeGuardError") {
+        res.writeHead(400, { "Content-Type": "application/json" });
+        res.end(JSON.stringify({ error: error.message }));
+        httpLogger(req, res, start, matchedApiName);
+      }
+      if (error instanceof Error) {
+        res.writeHead(500, { "Content-Type": "application/json" });
+        res.end(JSON.stringify({ error: error.message }));
+        httpLogger(req, res, start, matchedApiName);
+      } else {
+        res.writeHead(500, { "Content-Type": "application/json" });
+        res.end();
+        httpLogger(req, res, start, matchedApiName);
+      }
+    }
+  };
+};
+var createMainRouter = async (publicKey, clickhouseClient, temporalClient, enforceAuth, jwtConfig) => {
+  const apiRequestHandler = await apiHandler(
+    publicKey,
+    clickhouseClient,
+    temporalClient,
+    enforceAuth,
+    jwtConfig
+  );
+  const webApps = await getWebApps2();
+  const sortedWebApps = Array.from(webApps.values()).sort((a, b) => {
+    const pathA = a.config.mountPath || "/";
+    const pathB = b.config.mountPath || "/";
+    return pathB.length - pathA.length;
+  });
+  return async (req, res) => {
+    const start = Date.now();
+    const url = new URL(req.url || "", "http://localhost");
+    const pathname = url.pathname;
+    if (pathname === "/_moose_internal/health") {
+      res.writeHead(200, { "Content-Type": "application/json" });
+      res.end(
+        JSON.stringify({
+          status: "healthy",
+          timestamp: (/* @__PURE__ */ new Date()).toISOString()
+        })
+      );
+      return;
+    }
+    let jwtPayload;
+    if (publicKey && jwtConfig) {
+      const jwt = req.headers.authorization?.split(" ")[1];
+      if (jwt) {
+        try {
+          const { payload } = await jose.jwtVerify(jwt, publicKey, {
+            issuer: jwtConfig.issuer,
+            audience: jwtConfig.audience
+          });
+          jwtPayload = payload;
+        } catch (error) {
+          console.log("JWT verification failed for WebApp route");
+        }
+      }
+    }
+    for (const webApp of sortedWebApps) {
+      const mountPath = webApp.config.mountPath || "/";
+      const normalizedMount = mountPath.endsWith("/") && mountPath !== "/" ? mountPath.slice(0, -1) : mountPath;
+      const matches = pathname === normalizedMount || pathname.startsWith(normalizedMount + "/");
+      if (matches) {
+        if (webApp.config.injectMooseUtils !== false) {
+          const { getMooseUtils: getMooseUtils2 } = await Promise.resolve().then(() => (init_standalone(), standalone_exports));
+          req.moose = await getMooseUtils2();
+        }
+        let proxiedUrl = req.url;
+        if (normalizedMount !== "/") {
+          const pathWithoutMount = pathname.substring(normalizedMount.length) || "/";
+          proxiedUrl = pathWithoutMount + url.search;
+        }
+        try {
+          const modifiedReq = Object.assign(
+            Object.create(Object.getPrototypeOf(req)),
+            req,
+            {
+              url: proxiedUrl
+            }
+          );
+          await webApp.handler(modifiedReq, res);
+          return;
+        } catch (error) {
+          console.error(`Error in WebApp ${webApp.name}:`, error);
+          if (!res.headersSent) {
+            res.writeHead(500, { "Content-Type": "application/json" });
+            res.end(JSON.stringify({ error: "Internal Server Error" }));
+          }
+          return;
+        }
+      }
+    }
+    let apiPath = pathname;
+    if (pathname.startsWith("/api/")) {
+      apiPath = pathname.substring(4);
+    } else if (pathname.startsWith("/consumption/")) {
+      apiPath = pathname.substring(13);
+    }
+    if (apiPath !== pathname) {
+      const modifiedReq = Object.assign(
+        Object.create(Object.getPrototypeOf(req)),
+        req,
+        {
+          url: apiPath + url.search
+        }
+      );
+      await apiRequestHandler(modifiedReq, res);
+      return;
+    }
+    res.writeHead(404, { "Content-Type": "application/json" });
+    res.end(JSON.stringify({ error: "Not Found" }));
+    httpLogger(req, res, start);
+  };
+};
+var runApis = async (config) => {
+  const apisCluster = new Cluster({
+    maxWorkerCount: (config.workerCount ?? 0) > 0 ? config.workerCount : void 0,
+    workerStart: async () => {
+      let temporalClient;
+      if (config.temporalConfig) {
+        temporalClient = await getTemporalClient(
+          config.temporalConfig.url,
+          config.temporalConfig.namespace,
+          config.temporalConfig.clientCert,
+          config.temporalConfig.clientKey,
+          config.temporalConfig.apiKey
+        );
+      }
+      const clickhouseClient = getClickhouseClient(
+        toClientConfig2(config.clickhouseConfig)
+      );
+      let publicKey;
+      if (config.jwtConfig?.secret) {
+        console.log("Importing JWT public key...");
+        publicKey = await jose.importSPKI(config.jwtConfig.secret, "RS256");
+      }
+      const runtimeQueryClient = new QueryClient(clickhouseClient, "runtime");
+      globalThis._mooseRuntimeContext = {
+        client: new MooseClient(runtimeQueryClient, temporalClient)
+      };
+      const server = import_http.default.createServer(
+        await createMainRouter(
+          publicKey,
+          clickhouseClient,
+          temporalClient,
+          config.enforceAuth,
+          config.jwtConfig
+        )
+      );
+      const port = config.proxyPort !== void 0 ? config.proxyPort : 4001;
+      server.listen(port, "localhost", () => {
+        console.log(`Server running on port ${port}`);
+      });
+      return server;
+    },
+    workerStop: async (server) => {
+      return new Promise((resolve3) => {
+        server.close(() => resolve3());
+      });
+    }
+  });
+  apisCluster.start();
+};
+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"));
+init_commons();
+init_internal();
+init_json();
+var { Kafka: Kafka2 } = import_kafka_javascript2.KafkaJS;
+var HOSTNAME = process3.env.HOSTNAME;
+var AUTO_COMMIT_INTERVAL_MS = 5e3;
+var PARTITIONS_CONSUMED_CONCURRENTLY = 3;
+var MAX_RETRIES_CONSUMER = 150;
+var SESSION_TIMEOUT_CONSUMER = 3e4;
+var HEARTBEAT_INTERVAL_CONSUMER = 3e3;
+var DEFAULT_MAX_STREAMING_CONCURRENCY = 100;
+var CONSUMER_MAX_BATCH_SIZE = 1e3;
+var functionContextStorage = setupStructuredConsole(
+  (ctx) => ctx.functionName,
+  "function_name"
+);
+var MAX_STREAMING_CONCURRENCY = process3.env.MAX_STREAMING_CONCURRENCY ? parseInt(process3.env.MAX_STREAMING_CONCURRENCY, 10) : DEFAULT_MAX_STREAMING_CONCURRENCY;
+var metricsLog = (log) => {
+  const req = http2.request({
+    port: parseInt(process3.env.MOOSE_MANAGEMENT_PORT ?? "5001", 10),
+    method: "POST",
+    path: "/metrics-logs"
+  });
+  req.on("error", (err) => {
+    console.log(
+      `Error ${err.name} sending metrics to management port.`,
+      err.message
+    );
+  });
+  req.write(JSON.stringify({ ...log }));
+  req.end();
+};
+var startProducer = async (logger2, producer) => {
+  try {
+    logger2.log("Connecting producer...");
+    await producer.connect();
+    logger2.log("Producer is running...");
+  } catch (error) {
+    logger2.error("Failed to connect producer:");
+    if (error instanceof Error) {
+      logError(logger2, error);
+    }
+    throw error;
+  }
+};
+var stopProducer = async (logger2, producer) => {
+  await producer.disconnect();
+  logger2.log("Producer is shutting down...");
+};
+var stopConsumer = async (logger2, consumer, sourceTopic) => {
+  try {
+    logger2.log("Pausing consumer...");
+    const partitionNumbers = Array.from(
+      { length: sourceTopic.partitions },
+      (_, i) => i
+    );
+    await consumer.pause([
+      {
+        topic: sourceTopic.name,
+        partitions: partitionNumbers
+      }
+    ]);
+    logger2.log("Disconnecting consumer...");
+    await consumer.disconnect();
+    logger2.log("Consumer is shutting down...");
+  } catch (error) {
+    logger2.error(`Error during consumer shutdown: ${error}`);
+    try {
+      await consumer.disconnect();
+      logger2.log("Consumer disconnected after error");
+    } catch (disconnectError) {
+      logger2.error(`Failed to disconnect consumer: ${disconnectError}`);
+    }
+  }
+};
+var handleMessage = async (logger2, streamingFunctionWithConfigList, message, producer, fieldMutations, logPayloads) => {
+  if (message.value === void 0 || message.value === null) {
+    logger2.log(`Received message with no value, skipping...`);
+    return void 0;
+  }
+  try {
+    let payloadBuffer = message.value;
+    if (payloadBuffer && payloadBuffer.length >= 5 && payloadBuffer[0] === 0) {
+      payloadBuffer = payloadBuffer.subarray(5);
+    }
+    const parsedData = JSON.parse(payloadBuffer.toString());
+    mutateParsedJson(parsedData, fieldMutations);
+    if (logPayloads) {
+      logger2.log(`[PAYLOAD:STREAM_IN] ${JSON.stringify(parsedData)}`);
+    }
+    const transformedData = await Promise.all(
+      streamingFunctionWithConfigList.map(async ([fn, config]) => {
+        try {
+          return await fn(parsedData);
+        } catch (e) {
+          const deadLetterQueue = config.deadLetterQueue;
+          if (deadLetterQueue) {
+            const deadLetterRecord = {
+              originalRecord: {
+                ...parsedData,
+                // Include original Kafka message metadata
+                __sourcePartition: message.partition,
+                __sourceOffset: message.offset,
+                __sourceTimestamp: message.timestamp
+              },
+              errorMessage: e instanceof Error ? e.message : String(e),
+              errorType: e instanceof Error ? e.constructor.name : "Unknown",
+              failedAt: /* @__PURE__ */ new Date(),
+              source: "transform"
+            };
+            cliLog({
+              action: "DeadLetter",
+              message: `Sending message to DLQ ${deadLetterQueue.name}: ${e instanceof Error ? e.message : String(e)}`,
+              message_type: "Error"
+            });
+            try {
+              await producer.send({
+                topic: deadLetterQueue.name,
+                messages: [{ value: JSON.stringify(deadLetterRecord) }]
+              });
+            } catch (dlqError) {
+              logger2.error(`Failed to send to dead letter queue: ${dlqError}`);
+            }
+          } else {
+            cliLog({
+              action: "Function",
+              message: `Error processing message (no DLQ configured): ${e instanceof Error ? e.message : String(e)}`,
+              message_type: "Error"
+            });
+          }
+          throw e;
+        }
+      })
+    );
+    const processedMessages = transformedData.map((userFunctionOutput, i) => {
+      const [_, config] = streamingFunctionWithConfigList[i];
+      if (userFunctionOutput) {
+        if (Array.isArray(userFunctionOutput)) {
+          return userFunctionOutput.flat().filter((item) => item !== void 0 && item !== null).map((item) => ({
+            value: JSON.stringify(item),
+            originalValue: parsedData,
+            originalMessage: message,
+            dlq: config.deadLetterQueue ?? void 0
+          }));
+        } else {
+          return [
+            {
+              value: JSON.stringify(userFunctionOutput),
+              originalValue: parsedData,
+              originalMessage: message,
+              dlq: config.deadLetterQueue ?? void 0
+            }
+          ];
+        }
+      }
+    }).flat().filter((item) => item !== void 0 && item !== null);
+    if (logPayloads) {
+      if (processedMessages.length > 0) {
+        const outgoingJsonStrings = processedMessages.map((msg) => msg.value);
+        logger2.log(`[PAYLOAD:STREAM_OUT] [${outgoingJsonStrings.join(",")}]`);
+      } else {
+        logger2.log(`[PAYLOAD:STREAM_OUT] (no output from streaming function)`);
+      }
+    }
+    return processedMessages;
+  } catch (e) {
+    logger2.error(`Failed to transform data`);
+    if (e instanceof Error) {
+      logError(logger2, e);
+    }
+  }
+  return void 0;
+};
+var handleDLQForFailedMessages = async (logger2, producer, messages, error) => {
+  let messagesHandledByDLQ = 0;
+  let messagesWithoutDLQ = 0;
+  let dlqErrors = 0;
+  for (const msg of messages) {
+    if (msg.dlq && msg.originalValue) {
+      const deadLetterRecord = {
+        originalRecord: {
+          ...msg.originalValue,
+          // Include original Kafka message metadata
+          __sourcePartition: msg.originalMessage.partition,
+          __sourceOffset: msg.originalMessage.offset,
+          __sourceTimestamp: msg.originalMessage.timestamp
+        },
+        errorMessage: error instanceof Error ? error.message : String(error),
+        errorType: error instanceof Error ? error.constructor.name : "Unknown",
+        failedAt: /* @__PURE__ */ new Date(),
+        source: "transform"
+      };
+      cliLog({
+        action: "DeadLetter",
+        message: `Sending failed message to DLQ ${msg.dlq.name}: ${error instanceof Error ? error.message : String(error)}`,
+        message_type: "Error"
+      });
+      try {
+        await producer.send({
+          topic: msg.dlq.name,
+          messages: [{ value: JSON.stringify(deadLetterRecord) }]
+        });
+        logger2.log(`Sent failed message to DLQ ${msg.dlq.name}`);
+        messagesHandledByDLQ++;
+      } catch (dlqError) {
+        logger2.error(`Failed to send to DLQ: ${dlqError}`);
+        dlqErrors++;
+      }
+    } else if (!msg.dlq) {
+      messagesWithoutDLQ++;
+      logger2.warn(`Cannot send to DLQ: no DLQ configured for message`);
+    } else {
+      messagesWithoutDLQ++;
+      logger2.warn(`Cannot send to DLQ: original message value not available`);
+    }
+  }
+  const allMessagesHandled = messagesHandledByDLQ === messages.length && messagesWithoutDLQ === 0 && dlqErrors === 0;
+  if (allMessagesHandled) {
+    logger2.log(
+      `All ${messagesHandledByDLQ} failed message(s) sent to DLQ, suppressing original error`
+    );
+  } else if (messagesHandledByDLQ > 0) {
+    logger2.warn(
+      `Partial DLQ success: ${messagesHandledByDLQ}/${messages.length} message(s) sent to DLQ`
+    );
+    if (messagesWithoutDLQ > 0) {
+      logger2.error(
+        `Cannot handle batch failure: ${messagesWithoutDLQ} message(s) have no DLQ configured or missing original value`
+      );
+    }
+    if (dlqErrors > 0) {
+      logger2.error(`${dlqErrors} message(s) failed to send to DLQ`);
+    }
+  }
+  return allMessagesHandled;
+};
+var sendMessages = async (logger2, metrics, targetTopic, producer, messages) => {
+  if (messages.length === 0) return;
+  try {
+    await producer.send({
+      topic: targetTopic.name,
+      messages
+    });
+    for (const msg of messages) {
+      metrics.bytes += import_node_buffer.Buffer.byteLength(msg.value, "utf8");
+    }
+    metrics.count_out += messages.length;
+    logger2.log(`Sent ${messages.length} messages to ${targetTopic.name}`);
+  } catch (e) {
+    logger2.error(`Failed to send transformed data`);
+    if (e instanceof Error) {
+      logError(logger2, e);
+    }
+    const allHandledByDLQ = await handleDLQForFailedMessages(
+      logger2,
+      producer,
+      messages,
+      e
+    );
+    if (!allHandledByDLQ) {
+      throw e;
+    }
+  }
+};
+var sendMessageMetrics = (logger2, metrics) => {
+  if (metrics.count_in > 0 || metrics.count_out > 0 || metrics.bytes > 0) {
+    metricsLog({
+      count_in: metrics.count_in,
+      count_out: metrics.count_out,
+      function_name: logger2.logPrefix,
+      bytes: metrics.bytes,
+      timestamp: /* @__PURE__ */ new Date()
+    });
+  }
+  metrics.count_in = 0;
+  metrics.bytes = 0;
+  metrics.count_out = 0;
+  setTimeout(() => sendMessageMetrics(logger2, metrics), 1e3);
+};
+async function loadStreamingFunction(sourceTopic, targetTopic) {
+  const transformFunctions = await getStreamingFunctions();
+  const transformFunctionKey = `${topicNameToStreamName(sourceTopic)}_${targetTopic ? topicNameToStreamName(targetTopic) : "<no-target>"}`;
+  const matchingEntries = Array.from(transformFunctions.entries()).filter(
+    ([key]) => key.startsWith(transformFunctionKey)
+  );
+  if (matchingEntries.length === 0) {
+    const message = `No functions found for ${transformFunctionKey}`;
+    cliLog({
+      action: "Function",
+      message: `${message}`,
+      message_type: "Error"
+    });
+    throw new Error(message);
+  }
+  const functions = matchingEntries.map(([_, [fn, config]]) => [
+    fn,
+    config
+  ]);
+  const [_key, firstEntry] = matchingEntries[0];
+  const sourceColumns = firstEntry[2];
+  const fieldMutations = buildFieldMutationsFromColumns(sourceColumns);
+  return { functions, fieldMutations };
+}
+var startConsumer = async (args, logger2, metrics, _parallelism, consumer, producer, streamingFuncId) => {
+  validateTopicConfig(args.sourceTopic);
+  if (args.targetTopic) {
+    validateTopicConfig(args.targetTopic);
+  }
+  try {
+    logger2.log("Connecting consumer...");
+    await consumer.connect();
+    logger2.log("Consumer connected successfully");
+  } catch (error) {
+    logger2.error("Failed to connect consumer:");
+    if (error instanceof Error) {
+      logError(logger2, error);
+    }
+    throw error;
+  }
+  logger2.log(
+    `Starting consumer group '${streamingFuncId}' with source topic: ${args.sourceTopic.name} and target topic: ${args.targetTopic?.name || "none"}`
+  );
+  const result = await loadStreamingFunction(
+    args.sourceTopic,
+    args.targetTopic
+  );
+  const streamingFunctions = result.functions;
+  const fieldMutations = result.fieldMutations;
+  await consumer.subscribe({
+    topics: [args.sourceTopic.name]
+    // Use full topic name for Kafka operations
+  });
+  await consumer.run({
+    eachBatchAutoResolve: true,
+    // Enable parallel processing of partitions
+    partitionsConsumedConcurrently: PARTITIONS_CONSUMED_CONCURRENTLY,
+    // To be adjusted
+    eachBatch: async ({ batch, heartbeat, isRunning, isStale }) => {
+      if (!isRunning() || isStale()) {
+        return;
+      }
+      const functionName = logger2.logPrefix;
+      await functionContextStorage.run({ functionName }, async () => {
+        metrics.count_in += batch.messages.length;
+        cliLog({
+          action: "Received",
+          message: `${logger2.logPrefix.replace("__", " -> ")} ${batch.messages.length} message(s)`
+        });
+        logger2.log(`Received ${batch.messages.length} message(s)`);
+        let index = 0;
+        const readableStream = import_node_stream2.Readable.from(batch.messages);
+        const processedMessages = await readableStream.map(
+          async (message) => {
+            index++;
+            if (batch.messages.length > DEFAULT_MAX_STREAMING_CONCURRENCY && index % DEFAULT_MAX_STREAMING_CONCURRENCY || index - 1 === batch.messages.length) {
+              await heartbeat();
+            }
+            return handleMessage(
+              logger2,
+              streamingFunctions,
+              message,
+              producer,
+              fieldMutations,
+              args.logPayloads
+            );
+          },
+          {
+            concurrency: MAX_STREAMING_CONCURRENCY
+          }
+        ).toArray();
+        const filteredMessages = processedMessages.flat().filter((msg) => msg !== void 0 && msg.value !== void 0);
+        if (args.targetTopic === void 0 || processedMessages.length === 0) {
+          return;
+        }
+        await heartbeat();
+        if (filteredMessages.length > 0) {
+          await sendMessages(
+            logger2,
+            metrics,
+            args.targetTopic,
+            producer,
+            filteredMessages
+          );
+        }
+      });
+    }
+  });
+  logger2.log("Consumer is running...");
+};
+var buildLogger = (args, workerId) => {
+  const sourceBaseName = topicNameToStreamName(args.sourceTopic);
+  const targetBaseName = args.targetTopic ? topicNameToStreamName(args.targetTopic) : void 0;
+  const functionName = targetBaseName ? `${sourceBaseName}__${targetBaseName}` : sourceBaseName;
+  const logPrefix = `${functionName} (worker ${workerId})`;
+  return {
+    // logPrefix is used for structured logging (function_name field)
+    // Must match source_primitive.name format for log correlation
+    logPrefix: functionName,
+    log: (message) => {
+      console.log(`${logPrefix}: ${message}`);
+    },
+    error: (message) => {
+      console.error(`${logPrefix}: ${message}`);
+    },
+    warn: (message) => {
+      console.warn(`${logPrefix}: ${message}`);
+    }
+  };
+};
+function formatVersionSuffix(version) {
+  return `_${version.replace(/\./g, "_")}`;
+}
+function topicNameToStreamName(config) {
+  let name = config.name;
+  if (config.version) {
+    const versionSuffix = formatVersionSuffix(config.version);
+    if (name.endsWith(versionSuffix)) {
+      name = name.slice(0, -versionSuffix.length);
+    } else {
+      throw new Error(
+        `Version suffix ${versionSuffix} not found in topic name ${name}`
+      );
+    }
+  }
+  if (config.namespace && config.namespace !== "") {
+    const prefix = `${config.namespace}.`;
+    if (name.startsWith(prefix)) {
+      name = name.slice(prefix.length);
+    } else {
+      throw new Error(
+        `Namespace prefix ${prefix} not found in topic name ${name}`
+      );
+    }
+  }
+  return name;
+}
+function validateTopicConfig(config) {
+  if (config.namespace && !config.name.startsWith(`${config.namespace}.`)) {
+    throw new Error(
+      `Topic name ${config.name} must start with namespace ${config.namespace}`
+    );
+  }
+  if (config.version) {
+    const versionSuffix = formatVersionSuffix(config.version);
+    if (!config.name.endsWith(versionSuffix)) {
+      throw new Error(
+        `Topic name ${config.name} must end with version ${config.version}`
+      );
+    }
+  }
+}
+var runStreamingFunctions = async (args) => {
+  validateTopicConfig(args.sourceTopic);
+  if (args.targetTopic) {
+    validateTopicConfig(args.targetTopic);
+  }
+  const streamingFuncId = `flow-${args.sourceTopic.name}-${args.targetTopic?.name || ""}`;
+  const cluster2 = new Cluster({
+    maxCpuUsageRatio: 0.5,
+    maxWorkerCount: args.maxSubscriberCount,
+    workerStart: async (worker, parallelism) => {
+      const logger2 = buildLogger(args, worker.id);
+      const functionName = logger2.logPrefix;
+      return await functionContextStorage.run({ functionName }, async () => {
+        const metrics = {
+          count_in: 0,
+          count_out: 0,
+          bytes: 0
+        };
+        setTimeout(() => sendMessageMetrics(logger2, metrics), 1e3);
+        const clientIdPrefix = HOSTNAME ? `${HOSTNAME}-` : "";
+        const processId = `${clientIdPrefix}${streamingFuncId}-ts-${worker.id}`;
+        const kafka = await getKafkaClient(
+          {
+            clientId: processId,
+            broker: args.broker,
+            securityProtocol: args.securityProtocol,
+            saslUsername: args.saslUsername,
+            saslPassword: args.saslPassword,
+            saslMechanism: args.saslMechanism
+          },
+          logger2
+        );
+        const consumer = kafka.consumer({
+          kafkaJS: {
+            groupId: streamingFuncId,
+            sessionTimeout: SESSION_TIMEOUT_CONSUMER,
+            heartbeatInterval: HEARTBEAT_INTERVAL_CONSUMER,
+            retry: {
+              retries: MAX_RETRIES_CONSUMER
+            },
+            autoCommit: true,
+            autoCommitInterval: AUTO_COMMIT_INTERVAL_MS,
+            fromBeginning: true
+          },
+          "js.consumer.max.batch.size": CONSUMER_MAX_BATCH_SIZE
+        });
+        const maxMessageBytes = args.targetTopic?.max_message_bytes || 1024 * 1024;
+        const producer = kafka.producer(
+          createProducerConfig(maxMessageBytes)
+        );
+        try {
+          logger2.log("Starting producer...");
+          await startProducer(logger2, producer);
+          try {
+            logger2.log("Starting consumer...");
+            await startConsumer(
+              args,
+              logger2,
+              metrics,
+              parallelism,
+              consumer,
+              producer,
+              streamingFuncId
+            );
+          } catch (e) {
+            logger2.error("Failed to start kafka consumer: ");
+            if (e instanceof Error) {
+              logError(logger2, e);
+            }
+            throw e;
+          }
+        } catch (e) {
+          logger2.error("Failed to start kafka producer: ");
+          if (e instanceof Error) {
+            logError(logger2, e);
+          }
+          throw e;
+        }
+        return [logger2, producer, consumer];
+      });
+    },
+    workerStop: async ([logger2, producer, consumer]) => {
+      const functionName = logger2.logPrefix;
+      await functionContextStorage.run({ functionName }, async () => {
+        logger2.log(`Received SIGTERM, shutting down gracefully...`);
+        logger2.log("Stopping consumer first...");
+        await stopConsumer(logger2, consumer, args.sourceTopic);
+        logger2.log("Waiting for in-flight messages to complete...");
+        await new Promise((resolve3) => setTimeout(resolve3, 2e3));
+        logger2.log("Stopping producer...");
+        await stopProducer(logger2, producer);
+        logger2.log("Graceful shutdown completed");
+      });
+    }
+  });
+  cluster2.start();
+};
+init_compiler_config();
+async function runExportSerializer(targetModel) {
+  const useCompiled2 = shouldUseCompiled();
+  const sourceDir = getSourceDir();
+  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 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"));
+init_internal();
+var import_activity = require_activity();
+var import_workflow3 = require_workflow();
+init_internal();
+init_json();
+var taskContextStorage = setupStructuredConsole(
+  (ctx) => ctx.taskName,
+  "task_name"
+);
+var TASK_CONTEXT_FIELD_NAME = "task_name";
+var getTaskContextField = (ctx) => ctx.taskName;
+var activities = {
+  async hasWorkflow(name) {
+    try {
+      const workflows = await getWorkflows2();
+      const hasWorkflow = workflows.has(name);
+      import_activity.log.info(`Found workflow:: ${hasWorkflow}`);
+      return hasWorkflow;
+    } catch (error) {
+      import_activity.log.error(`Failed to check if workflow ${name} exists: ${error}`);
+      return false;
+    }
+  },
+  async getWorkflowByName(name) {
+    try {
+      import_activity.log.info(`Getting workflow ${name}`);
+      const workflows = await getWorkflows2();
+      if (workflows.has(name)) {
+        import_activity.log.info(`Workflow ${name} found`);
+        return workflows.get(name);
+      } else {
+        const errorData = {
+          error: "Workflow not found",
+          details: `Workflow ${name} not found`,
+          stack: void 0
+        };
+        const errorMsg = JSON.stringify(errorData);
+        import_activity.log.error(errorMsg);
+        throw new Error(errorMsg);
+      }
+    } catch (error) {
+      const errorData = {
+        error: "Failed to get workflow",
+        details: error instanceof Error ? error.message : String(error),
+        stack: error instanceof Error ? error.stack : void 0
+      };
+      const errorMsg = JSON.stringify(errorData);
+      import_activity.log.error(errorMsg);
+      throw new Error(errorMsg);
+    }
+  },
+  async getTaskForWorkflow(workflowName, taskName) {
+    try {
+      import_activity.log.info(`Getting task ${taskName} from workflow ${workflowName}`);
+      const task = await getTaskForWorkflow(workflowName, taskName);
+      import_activity.log.info(`Task ${taskName} found in workflow ${workflowName}`);
+      return task;
+    } catch (error) {
+      const errorData = {
+        error: "Failed to get task",
+        details: error instanceof Error ? error.message : String(error),
+        stack: error instanceof Error ? error.stack : void 0
+      };
+      const errorMsg = JSON.stringify(errorData);
+      import_activity.log.error(errorMsg);
+      throw new Error(errorMsg);
+    }
+  },
+  async executeTask(workflow, task, inputData) {
+    const context = import_activity.Context.current();
+    const taskState = {};
+    const taskIdentifier = workflow.name;
+    return await taskContextStorage.run(
+      { taskName: taskIdentifier },
+      async () => {
+        let heartbeatInterval = null;
+        const startPeriodicHeartbeat = () => {
+          heartbeatInterval = setInterval(() => {
+            context.heartbeat(`Task ${task.name} in progress`);
+          }, 5e3);
+        };
+        const stopPeriodicHeartbeat = () => {
+          if (heartbeatInterval) {
+            clearInterval(heartbeatInterval);
+            heartbeatInterval = null;
+          }
+        };
+        try {
+          import_activity.log.info(
+            `Task ${task.name} received input: ${JSON.stringify(inputData)}`
+          );
+          context.heartbeat(`Starting task: ${task.name}`);
+          const fullTask = await getTaskForWorkflow(workflow.name, task.name);
+          const revivedInputData = inputData ? JSON.parse(JSON.stringify(inputData), jsonDateReviver) : inputData;
+          try {
+            startPeriodicHeartbeat();
+            const result = await Promise.race([
+              fullTask.config.run({
+                state: taskState,
+                input: revivedInputData
+              }),
+              context.cancelled
+            ]);
+            return result;
+          } catch (error) {
+            if ((0, import_workflow3.isCancellation)(error)) {
+              import_activity.log.info(
+                `Task ${task.name} cancelled, calling onCancel handler if it exists`
+              );
+              if (fullTask.config.onCancel) {
+                await fullTask.config.onCancel({
+                  state: taskState,
+                  input: revivedInputData
+                });
+              }
+              return [];
+            } else {
+              throw error;
+            }
+          } finally {
+            stopPeriodicHeartbeat();
+          }
+        } catch (error) {
+          const errorData = {
+            error: "Task execution failed",
+            details: error instanceof Error ? error.message : String(error),
+            stack: error instanceof Error ? error.stack : void 0
+          };
+          const errorMsg = JSON.stringify(errorData);
+          import_activity.log.error(errorMsg);
+          throw new Error(errorMsg);
+        }
+      }
+    );
+  }
+};
+function createActivityForScript(scriptName) {
+  return {
+    [scriptName]: activities.executeTask
+  };
+}
+var import_worker = require_worker();
+var LoggerSingleton = class _LoggerSingleton {
+  static instance = null;
+  constructor() {
+  }
+  static initializeLogger() {
+    if (!_LoggerSingleton.instance) {
+      _LoggerSingleton.instance = new import_worker.DefaultLogger(
+        "DEBUG",
+        ({ level, message }) => {
+          const structuredLevel = level.toLowerCase();
+          const emitted = emitStructuredLog(
+            taskContextStorage,
+            getTaskContextField,
+            TASK_CONTEXT_FIELD_NAME,
+            structuredLevel,
+            message
+          );
+          if (!emitted) {
+            console.log(`${level} | ${message}`);
+          }
+        }
+      );
+      import_worker.Runtime.install({
+        logger: _LoggerSingleton.instance,
+        telemetryOptions: {
+          logging: {
+            filter: (0, import_worker.makeTelemetryFilterString)({ core: "INFO", other: "INFO" }),
+            forward: {}
+          }
+        }
+      });
+    }
+    return _LoggerSingleton.instance;
+  }
+  static getInstance() {
+    return _LoggerSingleton.instance;
+  }
+};
+var initializeLogger = LoggerSingleton.initializeLogger;
+var ALREADY_REGISTERED = /* @__PURE__ */ new Set();
+function collectActivities(logger2, workflows) {
+  logger2.info(`Collecting tasks from workflows`);
+  const scriptNames = [];
+  for (const [name, workflow] of workflows.entries()) {
+    logger2.info(
+      `Registering workflow: ${name} with starting task: ${workflow.config.startingTask.name}`
+    );
+    scriptNames.push(`${name}/${workflow.config.startingTask.name}`);
+  }
+  return scriptNames;
+}
+async function createTemporalConnection(logger2, temporalConfig) {
+  logger2.info(
+    `Using temporal_url: ${temporalConfig.url} and namespace: ${temporalConfig.namespace}`
+  );
+  let connectionOptions = {
+    address: temporalConfig.url
+  };
+  if (temporalConfig.clientCert && temporalConfig.clientKey) {
+    logger2.info("Using TLS for secure Temporal");
+    const cert = await fs3.readFileSync(temporalConfig.clientCert);
+    const key = await fs3.readFileSync(temporalConfig.clientKey);
+    connectionOptions.tls = {
+      clientCertPair: {
+        crt: cert,
+        key
+      }
+    };
+  } else if (temporalConfig.apiKey) {
+    logger2.info(`Using API key for secure Temporal`);
+    connectionOptions.address = "us-west1.gcp.api.temporal.io:7233";
+    connectionOptions.apiKey = temporalConfig.apiKey;
+    connectionOptions.tls = {};
+    connectionOptions.metadata = {
+      "temporal-namespace": temporalConfig.namespace
+    };
+  }
+  logger2.info(`Connecting to Temporal at ${connectionOptions.address}`);
+  const maxRetries = 5;
+  const baseDelay = 1e3;
+  let attempt = 0;
+  while (true) {
+    try {
+      const connection = await import_worker2.NativeConnection.connect(connectionOptions);
+      logger2.info("Connected to Temporal server");
+      return connection;
+    } catch (err) {
+      attempt++;
+      logger2.error(`Connection attempt ${attempt} failed: ${err}`);
+      if (attempt >= maxRetries) {
+        logger2.error(`Failed to connect after ${attempt} attempts`);
+        throw err;
+      }
+      const backoff = baseDelay * Math.pow(2, attempt - 1);
+      logger2.warn(`Retrying connection in ${backoff}ms...`);
+      await new Promise((resolve3) => setTimeout(resolve3, backoff));
+    }
+  }
+}
+async function registerWorkflows(logger2, config) {
+  logger2.info(`Registering workflows`);
+  if (!config.temporalConfig) {
+    logger2.info(`Temporal config not provided, skipping workflow registration`);
+    return null;
+  }
+  const allScriptPaths = [];
+  const dynamicActivities = [];
+  try {
+    const workflows = await getWorkflows2();
+    if (workflows.size > 0) {
+      logger2.info(`Found ${workflows.size} workflows`);
+      allScriptPaths.push(...collectActivities(logger2, workflows));
+      if (allScriptPaths.length === 0) {
+        logger2.info(`No tasks found in workflows`);
+        return null;
+      }
+      logger2.info(`Found ${allScriptPaths.length} tasks in workflows`);
+      for (const activityName of allScriptPaths) {
+        if (!ALREADY_REGISTERED.has(activityName)) {
+          const activity = await createActivityForScript(activityName);
+          dynamicActivities.push(activity);
+          ALREADY_REGISTERED.add(activityName);
+          logger2.info(`Registered task ${activityName}`);
+        }
+      }
+      if (dynamicActivities.length === 0) {
+        logger2.info(`No dynamic activities found in workflows`);
+        return null;
+      }
+      logger2.info(
+        `Found ${dynamicActivities.length} dynamic activities in workflows`
+      );
+    }
+    if (allScriptPaths.length === 0) {
+      logger2.info(`No workflows found`);
+      return null;
+    }
+    logger2.info(`Found ${allScriptPaths.length} workflows`);
+    if (dynamicActivities.length === 0) {
+      logger2.info(`No tasks found`);
+      return null;
+    }
+    logger2.info(`Found ${dynamicActivities.length} task(s)`);
+    const connection = await createTemporalConnection(
+      logger2,
+      config.temporalConfig
+    );
+    const silentLogger = {
+      info: () => {
+      },
+      // Suppress info logs (webpack output)
+      debug: () => {
+      },
+      // Suppress debug logs
+      warn: () => {
+      },
+      // Suppress warnings if desired
+      log: () => {
+      },
+      // Suppress general logs
+      trace: () => {
+      },
+      // Suppress trace logs
+      error: (message, meta) => {
+        logger2.error(message, meta);
+      }
+    };
+    const workflowBundle = await (0, import_worker2.bundleWorkflowCode)({
+      workflowsPath: path4.resolve(__dirname, "scripts/workflow.js"),
+      logger: silentLogger
+    });
+    const worker = await import_worker2.Worker.create({
+      connection,
+      namespace: config.temporalConfig.namespace,
+      taskQueue: "typescript-script-queue",
+      workflowBundle,
+      activities: {
+        ...activities,
+        ...Object.fromEntries(
+          dynamicActivities.map((activity) => [
+            Object.keys(activity)[0],
+            Object.values(activity)[0]
+          ])
+        )
+      }
+    });
+    return worker;
+  } catch (error) {
+    logger2.error(`Error registering workflows: ${error}`);
+    throw error;
+  }
+}
+async function runScripts(config) {
+  const logger2 = initializeLogger();
+  process.on("uncaughtException", (error) => {
+    console.error(`[PROCESS] Uncaught Exception: ${error}`);
+    process.exit(1);
+  });
+  const worker = await registerWorkflows(logger2, config);
+  if (!worker) {
+    logger2.warn(
+      `No workflows found. To disable workflow infrastructure, set workflows=false in moose.config.toml`
+    );
+    process.exit(0);
+  }
+  let isShuttingDown = false;
+  async function handleSignal(signal) {
+    console.log(`[SHUTDOWN] Received ${signal}`);
+    if (isShuttingDown) {
+      return;
+    }
+    isShuttingDown = true;
+    try {
+      if (!worker) {
+        process.exit(0);
+      }
+      await Promise.race([
+        worker.shutdown(),
+        new Promise(
+          (_, reject) => setTimeout(() => reject(new Error("Shutdown timeout")), 3e3)
+        )
+      ]);
+      process.exit(0);
+    } catch (error) {
+      console.log(`[SHUTDOWN] Error: ${error}`);
+      process.exit(1);
+    }
+  }
+  ["SIGTERM", "SIGINT", "SIGHUP", "SIGQUIT"].forEach((signal) => {
+    process.on(signal, () => {
+      handleSignal(signal).catch((error) => {
+        console.log(`[SHUTDOWN] Error: ${error}`);
+        process.exit(1);
+      });
+    });
+  });
+  logger2.info("Starting TypeScript worker...");
+  try {
+    await worker.run();
+  } catch (error) {
+    console.log(`[SHUTDOWN] Error: ${error}`);
+    process.exit(1);
+  }
+  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 program = new import_commander.Command();
+program.name("moose-runner").description("Moose runner for various operations").version("1.0.0");
+program.command("dmv2-serializer").description("Load DMv2 index").action(async () => {
+  await dumpMooseInternal();
+});
+program.command("export-serializer").description("Run export serializer").argument("<target-model>", "Target model to serialize").action(async (targetModel) => {
+  await runExportSerializer(targetModel);
+});
+program.command("consumption-apis").description("Run consumption APIs").argument("<clickhouse-db>", "Clickhouse database name").argument("<clickhouse-host>", "Clickhouse host").argument("<clickhouse-port>", "Clickhouse port").argument("<clickhouse-username>", "Clickhouse username").argument("<clickhouse-password>", "Clickhouse password").option("--clickhouse-use-ssl", "Use SSL for Clickhouse connection", false).option("--jwt-secret <secret>", "JWT public key for verification").option("--jwt-issuer <issuer>", "Expected JWT issuer").option("--jwt-audience <audience>", "Expected JWT audience").option(
+  "--enforce-auth",
+  "Enforce authentication on all consumption APIs",
+  false
+).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").option("--proxy-port <port>", "Port to run the proxy server on", parseInt).option(
+  "--worker-count <count>",
+  "Number of worker processes for the consumption API cluster",
+  parseInt
+).action(
+  (clickhouseDb, clickhouseHost, clickhousePort, clickhouseUsername, clickhousePassword, options) => {
+    runApis({
+      clickhouseConfig: {
+        database: clickhouseDb,
+        host: clickhouseHost,
+        port: clickhousePort,
+        username: clickhouseUsername,
+        password: clickhousePassword,
+        useSSL: options.clickhouseUseSsl
+      },
+      jwtConfig: {
+        secret: options.jwtSecret,
+        issuer: options.jwtIssuer,
+        audience: options.jwtAudience
+      },
+      temporalConfig: options.temporalUrl ? {
+        url: options.temporalUrl,
+        namespace: options.temporalNamespace,
+        clientCert: options.clientCert,
+        clientKey: options.clientKey,
+        apiKey: options.apiKey
+      } : void 0,
+      enforceAuth: options.enforceAuth,
+      proxyPort: options.proxyPort,
+      workerCount: options.workerCount
+    });
+  }
+);
+program.command("streaming-functions").description("Run streaming functions").argument("<source-topic>", "Source topic configuration as JSON").argument("<function-file-path>", "Path to the function file").argument(
+  "<broker>",
+  "Kafka broker address(es) - comma-separated for multiple brokers (e.g., 'broker1:9092, broker2:9092'). Whitespace around commas is automatically trimmed."
+).argument("<max-subscriber-count>", "Maximum number of subscribers").option("--target-topic <target-topic>", "Target topic configuration as JSON").option("--sasl-username <username>", "SASL username").option("--sasl-password <password>", "SASL password").option("--sasl-mechanism <mechanism>", "SASL mechanism").option("--security-protocol <protocol>", "Security protocol").option("--log-payloads", "Log payloads for debugging", false).action(
+  (sourceTopic, functionFilePath, broker, maxSubscriberCount, options) => {
+    const config = {
+      sourceTopic: JSON.parse(sourceTopic),
+      targetTopic: options.targetTopic ? JSON.parse(options.targetTopic) : void 0,
+      functionFilePath,
+      broker,
+      maxSubscriberCount: parseInt(maxSubscriberCount),
+      logPayloads: options.logPayloads,
+      saslUsername: options.saslUsername,
+      saslPassword: options.saslPassword,
+      saslMechanism: options.saslMechanism,
+      securityProtocol: options.securityProtocol
+    };
+    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 ? {
+      url: options.temporalUrl,
+      namespace: options.temporalNamespace,
+      clientCert: options.clientCert,
+      clientKey: options.clientKey,
+      apiKey: options.apiKey
+    } : void 0
+  });
+});
+program.parse();