@514labs/moose-lib 0.6.296 → 0.6.297-ci-28-g84f3192e

package/dist/moose-runner.js

@@ -9,6 +9,10 @@ var __hasOwnProp = Object.prototype.hasOwnProperty;
 var __esm = (fn, res) => function __init() {
   return fn && (res = (0, fn[__getOwnPropNames(fn)[0]])(fn = 0)), res;
 };
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
 var __copyProps = (to, from, except, desc) => {
   if (from && typeof from === "object" || typeof from === "function") {
     for (let key of __getOwnPropNames(from))
@@ -26,6 +30,344 @@ var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__ge
   mod
 ));
 
+// src/dmv2/utils/stackTrace.ts
+var init_stackTrace = __esm({
+  "src/dmv2/utils/stackTrace.ts"() {
+    "use strict";
+  }
+});
+
+// src/dmv2/typedBase.ts
+var init_typedBase = __esm({
+  "src/dmv2/typedBase.ts"() {
+    "use strict";
+    init_stackTrace();
+  }
+});
+
+// src/dataModels/dataModelTypes.ts
+var init_dataModelTypes = __esm({
+  "src/dataModels/dataModelTypes.ts"() {
+    "use strict";
+  }
+});
+
+// src/sqlHelpers.ts
+function sql(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, isColumn, instanceofSql, Sql, toQuery, toQueryPreview, getValueFromParameter, mapToClickHouseType;
+var init_sqlHelpers = __esm({
+  "src/sqlHelpers.ts"() {
+    "use strict";
+    isTable = (value) => typeof value === "object" && value !== null && "kind" in value && value.kind === "OlapTable";
+    isColumn = (value) => typeof value === "object" && "name" in value && "annotations" in value;
+    instanceofSql = (value) => typeof value === "object" && "values" in value && "strings" in value;
+    Sql = class {
+      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) ? 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 {
+            this.values[pos++] = child;
+            this.strings[pos] = rawString;
+          }
+        }
+      }
+    };
+    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";
+    };
+  }
+});
+
+// src/blocks/helpers.ts
+var init_helpers = __esm({
+  "src/blocks/helpers.ts"() {
+    "use strict";
+    init_sqlHelpers();
+  }
+});
+
+// src/dmv2/sdk/olapTable.ts
+var import_node_stream, import_node_crypto;
+var init_olapTable = __esm({
+  "src/dmv2/sdk/olapTable.ts"() {
+    "use strict";
+    init_typedBase();
+    init_dataModelTypes();
+    init_helpers();
+    init_internal();
+    import_node_stream = require("stream");
+    import_node_crypto = require("crypto");
+    init_sqlHelpers();
+  }
+});
+
+// src/dmv2/sdk/stream.ts
+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();
+  }
+});
+
+// src/dmv2/sdk/workflow.ts
+var init_workflow = __esm({
+  "src/dmv2/sdk/workflow.ts"() {
+    "use strict";
+    init_internal();
+  }
+});
+
+// src/dmv2/sdk/ingestApi.ts
+var init_ingestApi = __esm({
+  "src/dmv2/sdk/ingestApi.ts"() {
+    "use strict";
+    init_typedBase();
+    init_internal();
+  }
+});
+
+// src/dmv2/sdk/consumptionApi.ts
+var init_consumptionApi = __esm({
+  "src/dmv2/sdk/consumptionApi.ts"() {
+    "use strict";
+    init_typedBase();
+    init_internal();
+  }
+});
+
+// src/dmv2/sdk/ingestPipeline.ts
+var init_ingestPipeline = __esm({
+  "src/dmv2/sdk/ingestPipeline.ts"() {
+    "use strict";
+    init_typedBase();
+    init_stream();
+    init_olapTable();
+    init_ingestApi();
+    init_helpers();
+  }
+});
+
+// src/dmv2/sdk/etlPipeline.ts
+var init_etlPipeline = __esm({
+  "src/dmv2/sdk/etlPipeline.ts"() {
+    "use strict";
+    init_workflow();
+  }
+});
+
+// src/dmv2/sdk/sqlResource.ts
+var init_sqlResource = __esm({
+  "src/dmv2/sdk/sqlResource.ts"() {
+    "use strict";
+    init_internal();
+    init_sqlHelpers();
+    init_stackTrace();
+  }
+});
+
+// src/dmv2/sdk/materializedView.ts
+var init_materializedView = __esm({
+  "src/dmv2/sdk/materializedView.ts"() {
+    "use strict";
+    init_helpers();
+    init_sqlHelpers();
+    init_olapTable();
+    init_sqlResource();
+  }
+});
+
+// src/dmv2/sdk/view.ts
+var init_view = __esm({
+  "src/dmv2/sdk/view.ts"() {
+    "use strict";
+    init_helpers();
+    init_sqlHelpers();
+    init_sqlResource();
+  }
+});
+
+// src/dmv2/sdk/lifeCycle.ts
+var init_lifeCycle = __esm({
+  "src/dmv2/sdk/lifeCycle.ts"() {
+    "use strict";
+  }
+});
+
+// src/dmv2/sdk/webApp.ts
+var init_webApp = __esm({
+  "src/dmv2/sdk/webApp.ts"() {
+    "use strict";
+    init_internal();
+  }
+});
+
+// src/dmv2/registry.ts
+var init_registry = __esm({
+  "src/dmv2/registry.ts"() {
+    "use strict";
+    init_internal();
+  }
+});
+
+// src/dmv2/index.ts
+var init_dmv2 = __esm({
+  "src/dmv2/index.ts"() {
+    "use strict";
+    init_olapTable();
+    init_stream();
+    init_workflow();
+    init_ingestApi();
+    init_consumptionApi();
+    init_ingestPipeline();
+    init_etlPipeline();
+    init_materializedView();
+    init_sqlResource();
+    init_view();
+    init_lifeCycle();
+    init_webApp();
+    init_registry();
+  }
+});
+
+// src/dataModels/types.ts
+var init_types = __esm({
+  "src/dataModels/types.ts"() {
+    "use strict";
+  }
+});
+
+// src/browserCompatible.ts
+var init_browserCompatible = __esm({
+  "src/browserCompatible.ts"() {
+    "use strict";
+    init_dmv2();
+    init_types();
+    init_sqlHelpers();
+  }
+});
+
 // src/commons.ts
 function isTruthy(value) {
   if (!value) return false;
@@ -155,165 +497,14 @@ var init_commons = __esm({
   }
 });
 
-// src/moose-runner.ts
-var import_ts_node = require("ts-node");
-
-// src/dmv2/internal.ts
-var import_process = __toESM(require("process"));
-
-// src/sqlHelpers.ts
-var isTable = (value) => typeof value === "object" && value !== null && "kind" in value && value.kind === "OlapTable";
-var isColumn = (value) => typeof value === "object" && "name" in value && "annotations" in value;
-function sql(strings, ...values) {
-  return new Sql(strings, values);
-}
-var instanceofSql = (value) => typeof value === "object" && "values" in value && "strings" in value;
-var Sql = class {
-  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) ? 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 {
-        this.values[pos++] = child;
-        this.strings[pos] = rawString;
-      }
-    }
-  }
-};
-var 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];
-};
-var 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 */";
-  }
-};
-var getValueFromParameter = (value) => {
-  if (Array.isArray(value)) {
-    const [type, val] = value;
-    if (type === "Identifier") return val;
-  }
-  return value;
-};
-function createClickhouseParameter(parameterIndex, value) {
-  return `{p${parameterIndex}:${mapToClickHouseType(value)}}`;
-}
-var 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;
+// src/secrets.ts
+var init_secrets = __esm({
+  "src/secrets.ts"() {
+    "use strict";
   }
-  return "String";
-};
-function emptyIfUndefined(value) {
-  return value === void 0 ? "" : value;
-}
-
-// src/dmv2/sdk/olapTable.ts
-var import_node_stream = require("stream");
-var import_node_crypto = require("crypto");
-
-// src/dmv2/sdk/stream.ts
-var import_node_crypto2 = require("crypto");
-
-// src/index.ts
-init_commons();
+});
 
 // src/consumption-apis/helpers.ts
-var import_client2 = require("@temporalio/client");
-var import_node_crypto3 = require("crypto");
-var import_perf_hooks = require("perf_hooks");
-var fs = __toESM(require("fs"));
 function formatElapsedTime(ms) {
   if (ms < 1e3) {
     return `${Math.round(ms)} ms`;
@@ -326,142 +517,6 @@ function formatElapsedTime(ms) {
   const remainingSeconds = seconds % 60;
   return `${minutes} minutes and ${remainingSeconds.toFixed(2)} seconds`;
 }
-var MooseClient = class {
-  query;
-  workflow;
-  constructor(queryClient, temporalClient) {
-    this.query = queryClient;
-    this.workflow = new WorkflowClient(temporalClient);
-  }
-};
-var 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;
-  }
-};
-var 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: {
-          maximumAttempts: config.retries
-        },
-        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 dmv2Workflow = workflows.get(name);
-    if (dmv2Workflow) {
-      return {
-        retries: dmv2Workflow.config.retries || 3,
-        timeout: dmv2Workflow.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];
-  }
-};
 async function getTemporalClient(temporalUrl, namespace, clientCert, clientKey, apiKey) {
   try {
     console.info(
@@ -498,538 +553,989 @@ async function getTemporalClient(temporalUrl, namespace, clientCert, clientKey,
     return void 0;
   }
 }
+var import_client2, import_node_crypto3, import_perf_hooks, fs, MooseClient, QueryClient, WorkflowClient;
+var init_helpers2 = __esm({
+  "src/consumption-apis/helpers.ts"() {
+    "use strict";
+    import_client2 = require("@temporalio/client");
+    import_node_crypto3 = require("crypto");
+    import_perf_hooks = require("perf_hooks");
+    fs = __toESM(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: {
+              maximumAttempts: config.retries
+            },
+            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 dmv2Workflow = workflows.get(name);
+        if (dmv2Workflow) {
+          return {
+            retries: dmv2Workflow.config.retries || 3,
+            timeout: dmv2Workflow.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];
+      }
+    };
+  }
+});
 
-// src/consumption-apis/runner.ts
-var import_http2 = __toESM(require("http"));
-init_commons();
-var jose = __toESM(require("jose"));
-
-// src/cluster-utils.ts
-var import_node_cluster = __toESM(require("cluster"));
-var import_node_os = require("os");
-var import_node_process = require("process");
-var DEFAULT_MAX_CPU_USAGE_RATIO = 0.7;
-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
-    );
+// src/consumption-apis/webAppHelpers.ts
+var init_webAppHelpers = __esm({
+  "src/consumption-apis/webAppHelpers.ts"() {
+    "use strict";
   }
-  /**
-   * 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))
-    );
+});
+
+// src/scripts/task.ts
+var init_task = __esm({
+  "src/scripts/task.ts"() {
+    "use strict";
   }
-  /**
-   * 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)();
+});
+
+// src/cluster-utils.ts
+var import_node_cluster, import_node_os, import_node_process, DEFAULT_MAX_CPU_USAGE_RATIO, RESTART_TIME_MS, SIGTERM, SIGINT, SHUTDOWN_WORKERS_INTERVAL, Cluster;
+var init_cluster_utils = __esm({
+  "src/cluster-utils.ts"() {
+    "use strict";
+    import_node_cluster = __toESM(require("cluster"));
+    import_node_os = require("os");
+    import_node_process = require("process");
+    DEFAULT_MAX_CPU_USAGE_RATIO = 0.7;
+    RESTART_TIME_MS = 1e4;
+    SIGTERM = "SIGTERM";
+    SIGINT = "SIGINT";
+    SHUTDOWN_WORKERS_INTERVAL = 500;
+    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");
         }
-      }, 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.maxCpuUsageRatio = options.maxCpuUsageRatio || DEFAULT_MAX_CPU_USAGE_RATIO;
+        this.usedCpuCount = this.computeCPUUsageCount(
+          this.maxCpuUsageRatio,
+          options.maxWorkerCount
         );
       }
-      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;
+      /**
+       * 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))
+        );
       }
-    });
-    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);
+      /**
+       * 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 {
-          console.info(
-            `${this.processStr} - shutdown before worker fully started`
+          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
           );
         }
-        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);
+      /**
+       * 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((resolve2, reject) => {
+          if (!import_node_cluster.default.isPrimary) {
+            return resolve2();
+          }
+          if (!import_node_cluster.default.workers) {
+            return resolve2();
+          }
+          const workerIds = Object.keys(import_node_cluster.default.workers);
+          if (workerIds.length == 0) {
+            return resolve2();
+          }
+          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 resolve2();
+            }
+          };
+          const interval = setInterval(cleanWorkers, SHUTDOWN_WORKERS_INTERVAL);
+        });
+      };
+    };
+  }
+});
+
+// src/config/configFile.ts
+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;
     }
-  };
-  /**
-   * 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((resolve2, reject) => {
-      if (!import_node_cluster.default.isPrimary) {
-        return resolve2();
+    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, toml, ConfigError;
+var init_configFile = __esm({
+  "src/config/configFile.ts"() {
+    "use strict";
+    import_node_path = __toESM(require("path"));
+    toml = __toESM(require("toml"));
+    ConfigError = class extends Error {
+      constructor(message) {
+        super(message);
+        this.name = "ConfigError";
+      }
+    };
+  }
+});
+
+// src/config/runtime.ts
+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;
       }
-      if (!import_node_cluster.default.workers) {
-        return resolve2();
+      setClickHouseConfig(config) {
+        this.clickhouseConfig = config;
       }
-      const workerIds = Object.keys(import_node_cluster.default.workers);
-      if (workerIds.length == 0) {
-        return resolve2();
+      setKafkaConfig(config) {
+        this.kafkaConfig = config;
       }
-      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 resolve2();
+      _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;
         }
-      };
-      const interval = setInterval(cleanWorkers, SHUTDOWN_WORKERS_INTERVAL);
-    });
-  };
-};
+      }
+      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();
+  }
+});
 
-// src/consumption-apis/runner.ts
-var toClientConfig = (config) => ({
-  ...config,
-  useSSL: config.useSSL ? "true" : "false"
+// src/consumption-apis/standalone.ts
+var standalone_exports = {};
+__export(standalone_exports, {
+  getMooseClients: () => getMooseClients,
+  getMooseUtils: () => getMooseUtils
 });
-var createPath = (apisDir, path3) => `${apisDir}${path3}.ts`;
-var httpLogger = (req, res, startMs) => {
-  console.log(
-    `${req.method} ${req.url} ${res.statusCode} ${Date.now() - startMs}ms`
+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."
   );
-};
-var modulesCache = /* @__PURE__ */ new Map();
-var apiHandler = async (publicKey, clickhouseClient, temporalClient, apisDir, enforceAuth, isDmv2, jwtConfig) => {
-  const apis = isDmv2 ? await getApis2() : /* @__PURE__ */ new Map();
-  return async (req, res) => {
-    const start = Date.now();
-    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) {
+  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, initPromise, toClientConfig;
+var init_standalone = __esm({
+  "src/consumption-apis/standalone.ts"() {
+    "use strict";
+    init_helpers2();
+    init_commons();
+    init_sqlHelpers();
+    standaloneUtils = null;
+    initPromise = null;
+    toClientConfig = (config) => ({
+      ...config,
+      useSSL: config.useSSL ? "true" : "false"
+    });
+  }
+});
+
+// src/consumption-apis/runner.ts
+var import_http2, jose, toClientConfig2, createPath, httpLogger, modulesCache, apiHandler, createMainRouter, runApis;
+var init_runner = __esm({
+  "src/consumption-apis/runner.ts"() {
+    "use strict";
+    import_http2 = __toESM(require("http"));
+    init_commons();
+    init_helpers2();
+    jose = __toESM(require("jose"));
+    init_cluster_utils();
+    init_sqlHelpers();
+    init_internal();
+    toClientConfig2 = (config) => ({
+      ...config,
+      useSSL: config.useSSL ? "true" : "false"
+    });
+    createPath = (apisDir, path4) => `${apisDir}${path4}.ts`;
+    httpLogger = (req, res, startMs) => {
+      console.log(
+        `${req.method} ${req.url} ${res.statusCode} ${Date.now() - startMs}ms`
+      );
+    };
+    modulesCache = /* @__PURE__ */ new Map();
+    apiHandler = async (publicKey, clickhouseClient, temporalClient, apisDir, enforceAuth, isDmv2, jwtConfig) => {
+      const apis = isDmv2 ? await getApis2() : /* @__PURE__ */ new Map();
+      return async (req, res) => {
+        const start = Date.now();
+        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;
           }
-        } 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 = createPath(apisDir, 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;
-        },
-        {}
-      );
-      let userFuncModule = modulesCache.get(pathName);
-      if (userFuncModule === void 0) {
-        if (isDmv2) {
-          let apiName = fileName.replace(/^\/+|\/+$/g, "");
-          let version = null;
-          userFuncModule = apis.get(apiName);
-          if (!userFuncModule) {
-            version = url.searchParams.get("version");
-            if (!version && apiName.includes("/")) {
-              const pathParts = apiName.split("/");
-              if (pathParts.length >= 2) {
-                userFuncModule = apis.get(apiName);
+          const pathName = createPath(apisDir, 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;
+            },
+            {}
+          );
+          let userFuncModule = modulesCache.get(pathName);
+          if (userFuncModule === void 0) {
+            if (isDmv2) {
+              let apiName = fileName.replace(/^\/+|\/+$/g, "");
+              let version = null;
+              userFuncModule = apis.get(apiName);
+              if (!userFuncModule) {
+                version = url.searchParams.get("version");
+                if (!version && apiName.includes("/")) {
+                  const pathParts = apiName.split("/");
+                  if (pathParts.length >= 2) {
+                    userFuncModule = apis.get(apiName);
+                    if (!userFuncModule) {
+                      apiName = pathParts[0];
+                      version = pathParts.slice(1).join("/");
+                    }
+                  }
+                }
                 if (!userFuncModule) {
-                  apiName = pathParts[0];
-                  version = pathParts.slice(1).join("/");
+                  if (version) {
+                    const versionedKey = `${apiName}:${version}`;
+                    userFuncModule = apis.get(versionedKey);
+                  } else {
+                    userFuncModule = apis.get(apiName);
+                  }
                 }
               }
-            }
-            if (!userFuncModule) {
-              if (version) {
-                const versionedKey = `${apiName}:${version}`;
-                userFuncModule = apis.get(versionedKey);
-              } else {
-                userFuncModule = apis.get(apiName);
+              if (!userFuncModule) {
+                const availableApis = Array.from(apis.keys()).map(
+                  (key) => key.replace(":", "/")
+                );
+                const errorMessage = version ? `API ${apiName} with version ${version} not found. Available APIs: ${availableApis.join(", ")}` : `API ${apiName} not found. Available APIs: ${availableApis.join(", ")}`;
+                throw new Error(errorMessage);
               }
+              modulesCache.set(pathName, userFuncModule);
+              console.log(`[API] | Executing API: ${apiName}`);
+            } else {
+              userFuncModule = require(pathName);
+              modulesCache.set(pathName, userFuncModule);
             }
           }
-          if (!userFuncModule) {
-            const availableApis = Array.from(apis.keys()).map(
-              (key) => key.replace(":", "/")
-            );
-            const errorMessage = version ? `API ${apiName} with version ${version} not found. Available APIs: ${availableApis.join(", ")}` : `API ${apiName} not found. Available APIs: ${availableApis.join(", ")}`;
-            throw new Error(errorMessage);
+          const queryClient = new QueryClient(clickhouseClient, fileName);
+          let result = isDmv2 ? await userFuncModule(paramsObject, {
+            client: new MooseClient(queryClient, temporalClient),
+            sql,
+            jwt: jwtPayload
+          }) : await userFuncModule.default(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);
+          } else {
+            res.writeHead(200, { "Content-Type": "application/json" });
+            httpLogger(req, res, start);
+          }
+          res.end(body);
+        } catch (error) {
+          console.log("error in path ", req.url, error);
+          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);
+          }
+          if (error instanceof Error) {
+            res.writeHead(500, { "Content-Type": "application/json" });
+            res.end(JSON.stringify({ error: error.message }));
+            httpLogger(req, res, start);
+          } else {
+            res.writeHead(500, { "Content-Type": "application/json" });
+            res.end();
+            httpLogger(req, res, start);
           }
-          modulesCache.set(pathName, userFuncModule);
-          console.log(`[API] | Executing API: ${apiName}`);
-        } else {
-          userFuncModule = require(pathName);
-          modulesCache.set(pathName, userFuncModule);
-        }
-      }
-      const queryClient = new QueryClient(clickhouseClient, fileName);
-      let result = isDmv2 ? await userFuncModule(paramsObject, {
-        client: new MooseClient(queryClient, temporalClient),
-        sql,
-        jwt: jwtPayload
-      }) : await userFuncModule.default(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);
-      } else {
-        res.writeHead(200, { "Content-Type": "application/json" });
-        httpLogger(req, res, start);
-      }
-      res.end(body);
-    } catch (error) {
-      console.log("error in path ", req.url, error);
-      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);
-      }
-      if (error instanceof Error) {
-        res.writeHead(500, { "Content-Type": "application/json" });
-        res.end(JSON.stringify({ error: error.message }));
-        httpLogger(req, res, start);
-      } else {
-        res.writeHead(500, { "Content-Type": "application/json" });
-        res.end();
-        httpLogger(req, res, start);
-      }
-    }
-  };
-};
-var createMainRouter = async (publicKey, clickhouseClient, temporalClient, apisDir, enforceAuth, isDmv2, jwtConfig) => {
-  const apiRequestHandler = await apiHandler(
-    publicKey,
-    clickhouseClient,
-    temporalClient,
-    apisDir,
-    enforceAuth,
-    isDmv2,
-    jwtConfig
-  );
-  const webApps = isDmv2 ? await getWebApps2() : /* @__PURE__ */ new Map();
-  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()
-        })
+      };
+    };
+    createMainRouter = async (publicKey, clickhouseClient, temporalClient, apisDir, enforceAuth, isDmv2, jwtConfig) => {
+      const apiRequestHandler = await apiHandler(
+        publicKey,
+        clickhouseClient,
+        temporalClient,
+        apisDir,
+        enforceAuth,
+        isDmv2,
+        jwtConfig
       );
-      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");
+      const webApps = isDmv2 ? await getWebApps2() : /* @__PURE__ */ new Map();
+      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;
         }
-      }
-    }
-    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 queryClient = new QueryClient(clickhouseClient, pathname);
-          req.moose = {
-            client: new MooseClient(queryClient, temporalClient),
-            sql,
-            jwt: jwtPayload
-          };
+        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 proxiedUrl = req.url;
-        if (normalizedMount !== "/") {
-          const pathWithoutMount = pathname.substring(normalizedMount.length) || "/";
-          proxiedUrl = pathWithoutMount + url.search;
+        let apiPath = pathname;
+        if (pathname.startsWith("/api/")) {
+          apiPath = pathname.substring(4);
+        } else if (pathname.startsWith("/consumption/")) {
+          apiPath = pathname.substring(13);
         }
-        try {
+        if (apiPath !== pathname) {
           const modifiedReq = Object.assign(
             Object.create(Object.getPrototypeOf(req)),
             req,
             {
-              url: proxiedUrl
+              url: apiPath + url.search
             }
           );
-          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" }));
-          }
+          await apiRequestHandler(modifiedReq, res);
           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
+        res.writeHead(404, { "Content-Type": "application/json" });
+        res.end(JSON.stringify({ error: "Not Found" }));
+        httpLogger(req, res, start);
+      };
+    };
+    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_http2.default.createServer(
+            await createMainRouter(
+              publicKey,
+              clickhouseClient,
+              temporalClient,
+              config.apisDir,
+              config.enforceAuth,
+              config.isDmv2,
+              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((resolve2) => {
+            server.close(() => resolve2());
+          });
         }
-      );
-      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(
-        toClientConfig(config.clickhouseConfig)
-      );
-      let publicKey;
-      if (config.jwtConfig?.secret) {
-        console.log("Importing JWT public key...");
-        publicKey = await jose.importSPKI(config.jwtConfig.secret, "RS256");
-      }
-      const server = import_http2.default.createServer(
-        await createMainRouter(
-          publicKey,
-          clickhouseClient,
-          temporalClient,
-          config.apisDir,
-          config.enforceAuth,
-          config.isDmv2,
-          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((resolve2) => {
-        server.close(() => resolve2());
       });
-    }
-  });
-  apisCluster.start();
-};
+      apisCluster.start();
+    };
+  }
+});
 
 // src/clients/redisClient.ts
-var import_redis = require("redis");
-
-// src/consumption-apis/standalone.ts
-init_commons();
-
-// src/utilities/dataParser.ts
-var import_csv_parse = require("csv-parse");
+var import_redis;
+var init_redisClient = __esm({
+  "src/clients/redisClient.ts"() {
+    "use strict";
+    import_redis = require("redis");
+  }
+});
 
 // src/utilities/json.ts
-var STRING_DATE_ANNOTATION = "stringDate";
 function isNullableType(dt) {
   return typeof dt === "object" && dt !== null && "nullable" in dt && typeof dt.nullable !== "undefined";
 }
@@ -1148,36 +1654,77 @@ function mutateParsedJson(data, fieldMutations) {
   }
   applyFieldMutations(data, fieldMutations);
 }
+var STRING_DATE_ANNOTATION;
+var init_json = __esm({
+  "src/utilities/json.ts"() {
+    "use strict";
+    STRING_DATE_ANNOTATION = "stringDate";
+  }
+});
 
 // src/utilities/dataParser.ts
-var CSV_DELIMITERS = {
-  COMMA: ",",
-  TAB: "	",
-  SEMICOLON: ";",
-  PIPE: "|"
-};
-var DEFAULT_CSV_CONFIG = {
-  delimiter: CSV_DELIMITERS.COMMA,
-  columns: true,
-  skipEmptyLines: true,
-  trim: true
-};
+var import_csv_parse, CSV_DELIMITERS, 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
+    };
+  }
+});
+
+// src/utilities/index.ts
+var init_utilities = __esm({
+  "src/utilities/index.ts"() {
+    "use strict";
+    init_dataParser();
+  }
+});
+
+// src/connectors/dataSource.ts
+var init_dataSource = __esm({
+  "src/connectors/dataSource.ts"() {
+    "use strict";
+  }
+});
+
+// src/index.ts
+var init_index = __esm({
+  "src/index.ts"() {
+    "use strict";
+    init_browserCompatible();
+    init_helpers();
+    init_commons();
+    init_secrets();
+    init_helpers2();
+    init_webAppHelpers();
+    init_task();
+    init_runner();
+    init_redisClient();
+    init_helpers2();
+    init_standalone();
+    init_sqlHelpers();
+    init_utilities();
+    init_dataSource();
+    init_types();
+  }
+});
 
 // src/dmv2/internal.ts
-init_commons();
 function getSourceDir() {
   return import_process.default.env.MOOSE_SOURCE_DIR || "app";
 }
-var 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()
-};
-var defaultRetentionPeriod = 60 * 60 * 24 * 7;
 function isS3QueueConfig(config) {
   return "engine" in config && config.engine === "S3Queue" /* S3Queue */;
 }
@@ -1414,364 +1961,387 @@ function convertTableConfigToEngineConfig(config) {
   }
   return void 0;
 }
-var toInfraMap = (registry) => {
-  const tables = {};
-  const topics = {};
-  const ingestApis = {};
-  const apis = {};
-  const sqlResources = {};
-  const workflows = {};
-  const webApps = {};
-  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";
+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;
       }
     }
-    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
+  }
+  return void 0;
+}
+var import_process, moose_internal, defaultRetentionPeriod, toInfraMap, getMooseInternal, dumpMooseInternal, loadIndex, getStreamingFunctions, getApis2, getWorkflows2, getTaskForWorkflow, getWebApps2;
+var init_internal = __esm({
+  "src/dmv2/internal.ts"() {
+    "use strict";
+    import_process = __toESM(require("process"));
+    init_index();
+    init_commons();
+    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()
     };
-  });
-  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
+    defaultRetentionPeriod = 60 * 60 * 24 * 7;
+    toInfraMap = (registry) => {
+      const tables = {};
+      const topics = {};
+      const ingestApis = {};
+      const apis = {};
+      const sqlResources = {};
+      const workflows = {};
+      const webApps = {};
+      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
+        };
       });
-    });
-    stream._consumers.forEach((consumer) => {
-      consumers.push({
-        version: consumer.config.version,
-        sourceFile: consumer.config.sourceFile
+      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
+        };
       });
-    });
-    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.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 {
+              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 {
+              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
+        };
+      });
+      return {
+        topics,
+        tables,
+        ingestApis,
+        apis,
+        sqlResources,
+        workflows,
+        webApps
+      };
     };
-  });
-  registry.ingestApis.forEach((api) => {
-    let metadata = api.metadata;
-    if (!metadata && api.config && api.pipelineParent) {
-      metadata = api.pipelineParent.metadata;
+    getMooseInternal = () => globalThis.moose_internal;
+    if (getMooseInternal() === void 0) {
+      globalThis.moose_internal = moose_internal;
     }
-    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
+    dumpMooseInternal = async () => {
+      loadIndex();
+      console.log(
+        "___MOOSE_STUFF___start",
+        JSON.stringify(toInfraMap(getMooseInternal())),
+        "end___MOOSE_STUFF___"
+      );
     };
-  });
-  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 {
-          throw new Error(`Unknown sql resource dependency type: ${r}`);
+    loadIndex = () => {
+      const registry = getMooseInternal();
+      registry.tables.clear();
+      registry.streams.clear();
+      registry.ingestApis.clear();
+      registry.apis.clear();
+      registry.sqlResources.clear();
+      registry.workflows.clear();
+      registry.webApps.clear();
+      const appDir = `${import_process.default.cwd()}/${getSourceDir()}`;
+      Object.keys(require.cache).forEach((key) => {
+        if (key.startsWith(appDir)) {
+          delete require.cache[key];
         }
-      }),
-      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 {
-          throw new Error(`Unknown sql resource dependency type: ${r}`);
+      });
+      try {
+        require(`${import_process.default.cwd()}/${getSourceDir()}/index.ts`);
+      } catch (error) {
+        let hint;
+        const details = error instanceof Error ? error.message : String(error);
+        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";
         }
-      })
-    };
-  });
-  registry.workflows.forEach((workflow) => {
-    workflows[workflow.name] = {
-      name: workflow.name,
-      retries: workflow.config.retries,
-      timeout: workflow.config.timeout,
-      schedule: workflow.config.schedule
+        const errorMsg = `${hint ?? ""}${details}`;
+        const cause = error instanceof Error ? error : void 0;
+        throw new Error(errorMsg, { cause });
+      }
     };
-  });
-  registry.webApps.forEach((webApp) => {
-    webApps[webApp.name] = {
-      name: webApp.name,
-      mountPath: webApp.config.mountPath || "/",
-      metadata: webApp.config.metadata
+    getStreamingFunctions = async () => {
+      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;
     };
-  });
-  return {
-    topics,
-    tables,
-    ingestApis,
-    apis,
-    sqlResources,
-    workflows,
-    webApps
-  };
-};
-var getMooseInternal = () => globalThis.moose_internal;
-if (getMooseInternal() === void 0) {
-  globalThis.moose_internal = moose_internal;
-}
-var dumpMooseInternal = async () => {
-  loadIndex();
-  console.log(
-    "___MOOSE_STUFF___start",
-    JSON.stringify(toInfraMap(getMooseInternal())),
-    "end___MOOSE_STUFF___"
-  );
-};
-var loadIndex = () => {
-  const registry = getMooseInternal();
-  registry.tables.clear();
-  registry.streams.clear();
-  registry.ingestApis.clear();
-  registry.apis.clear();
-  registry.sqlResources.clear();
-  registry.workflows.clear();
-  registry.webApps.clear();
-  const appDir = `${import_process.default.cwd()}/${getSourceDir()}`;
-  Object.keys(require.cache).forEach((key) => {
-    if (key.startsWith(appDir)) {
-      delete require.cache[key];
-    }
-  });
-  try {
-    require(`${import_process.default.cwd()}/${getSourceDir()}/index.ts`);
-  } catch (error) {
-    let hint;
-    const details = error instanceof Error ? error.message : String(error);
-    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";
-    }
-    const errorMsg = `${hint ?? ""}${details}`;
-    const cause = error instanceof Error ? error : void 0;
-    throw new Error(errorMsg, { cause });
-  }
-};
-var getStreamingFunctions = async () => {
-  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
-        ]);
+    getApis2 = async () => {
+      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);
+          }
+        }
       });
-    });
-    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;
-};
-var getApis2 = async () => {
-  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 () => {
+      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`);
       }
-    }
-  });
-  nameToSoleVersionHandler.forEach((handler, name) => {
-    if (!apiFunctions.has(name)) {
-      apiFunctions.set(name, handler);
-    }
-  });
-  return apiFunctions;
-};
-var getWorkflows2 = async () => {
-  loadIndex();
-  const registry = getMooseInternal();
-  return registry.workflows;
-};
-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;
+      const task = findTaskInTree(
+        workflow.config.startingTask,
+        taskName
+      );
+      if (!task) {
+        throw new Error(`Task ${taskName} not found in workflow ${workflowName}`);
       }
-    }
-  }
-  return void 0;
-}
-var 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 () => {
+      loadIndex();
+      return getMooseInternal().webApps;
+    };
   }
-  return task;
-};
-var getWebApps2 = async () => {
-  loadIndex();
-  return getMooseInternal().webApps;
-};
+});
+
+// src/moose-runner.ts
+var import_ts_node = require("ts-node");
+init_internal();
 
 // src/blocks/runner.ts
 var import_fastq = __toESM(require("fastq"));
 init_commons();
 var import_node_fs = __toESM(require("fs"));
-var import_node_path = __toESM(require("path"));
+var import_node_path2 = __toESM(require("path"));
 var walkDir = (dir, fileExtension, fileList) => {
   const files = import_node_fs.default.readdirSync(dir);
   files.forEach((file) => {
-    if (import_node_fs.default.statSync(import_node_path.default.join(dir, file)).isDirectory()) {
-      fileList = walkDir(import_node_path.default.join(dir, file), fileExtension, fileList);
+    if (import_node_fs.default.statSync(import_node_path2.default.join(dir, file)).isDirectory()) {
+      fileList = walkDir(import_node_path2.default.join(dir, file), fileExtension, fileList);
     } else if (file.endsWith(fileExtension)) {
-      fileList.push(import_node_path.default.join(dir, file));
+      fileList.push(import_node_path2.default.join(dir, file));
     }
   });
   return fileList;
@@ -1782,7 +2352,7 @@ var DependencyError = class extends Error {
     this.name = "DependencyError";
   }
 };
-var toClientConfig2 = (config) => ({
+var toClientConfig3 = (config) => ({
   ...config,
   useSSL: config.useSSL ? "true" : "false"
 });
@@ -1834,7 +2404,7 @@ var asyncWorker = async (task) => {
   await createBlocks(task.chClient, task.blocks);
 };
 var runBlocks = async (config) => {
-  const chClient = getClickhouseClient(toClientConfig2(config.clickhouseConfig));
+  const chClient = getClickhouseClient(toClientConfig3(config.clickhouseConfig));
   console.log(`Connected`);
   const blocksFiles = walkDir(config.blocksDir, ".ts", []);
   const numOfBlockFiles = blocksFiles.length;
@@ -1847,10 +2417,10 @@ var runBlocks = async (config) => {
       }
     }
   });
-  for (const path3 of blocksFiles) {
-    console.log(`Adding to queue: ${path3}`);
+  for (const path4 of blocksFiles) {
+    console.log(`Adding to queue: ${path4}`);
     try {
-      const blocks = require(path3).default;
+      const blocks = require(path4).default;
       queue.push({
         chClient,
         blocks,
@@ -1859,7 +2429,7 @@ var runBlocks = async (config) => {
     } catch (err) {
       cliLog({
         action: "Blocks",
-        message: `Failed to import blocks from ${path3}: ${err}`,
+        message: `Failed to import blocks from ${path4}: ${err}`,
         message_type: "Error"
       });
     }
@@ -1869,6 +2439,9 @@ var runBlocks = async (config) => {
   }
 };
 
+// src/moose-runner.ts
+init_runner();
+
 // src/streaming-functions/runner.ts
 var import_node_stream2 = require("stream");
 var import_kafka_javascript2 = require("@514labs/kafka-javascript");
@@ -1876,6 +2449,9 @@ var import_node_buffer = require("buffer");
 var process3 = __toESM(require("process"));
 var http3 = __toESM(require("http"));
 init_commons();
+init_cluster_utils();
+init_internal();
+init_json();
 var { Kafka: Kafka2 } = import_kafka_javascript2.KafkaJS;
 var HOSTNAME = process3.env.HOSTNAME;
 var AUTO_COMMIT_INTERVAL_MS = 5e3;
@@ -2434,12 +3010,15 @@ async function runApiTypeSerializer(targetModel) {
 
 // src/scripts/runner.ts
 var import_worker2 = require("@temporalio/worker");
-var path2 = __toESM(require("path"));
+var path3 = __toESM(require("path"));
 var fs3 = __toESM(require("fs"));
+init_internal();
 
 // src/scripts/activity.ts
 var import_activity = require("@temporalio/activity");
 var import_workflow3 = require("@temporalio/workflow");
+init_internal();
+init_json();
 var activities = {
   async hasDmv2Workflow(name) {
     try {
@@ -2724,7 +3303,7 @@ async function registerWorkflows(logger2, config) {
       }
     };
     const workflowBundle = await (0, import_worker2.bundleWorkflowCode)({
-      workflowsPath: path2.resolve(__dirname, "scripts/workflow.js"),
+      workflowsPath: path3.resolve(__dirname, "scripts/workflow.js"),
       logger: silentLogger
     });
     const worker = await import_worker2.Worker.create({