@514labs/moose-lib 0.6.295-ci-17-gc22400d0 → 0.6.295

package/dist/moose-runner.js

@@ -9,10 +9,6 @@ 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))
@@ -30,344 +26,6 @@ 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;
@@ -497,14 +155,165 @@ var init_commons = __esm({
   }
 });
 
-// src/secrets.ts
-var init_secrets = __esm({
-  "src/secrets.ts"() {
-    "use strict";
+// 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;
+  }
+  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`;
@@ -517,6 +326,142 @@ 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(
@@ -553,989 +498,538 @@ 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/webAppHelpers.ts
-var init_webAppHelpers = __esm({
-  "src/consumption-apis/webAppHelpers.ts"() {
-    "use strict";
-  }
-});
 
-// src/scripts/task.ts
-var init_task = __esm({
-  "src/scripts/task.ts"() {
-    "use strict";
-  }
-});
+// 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, 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");
-        }
-        this.maxCpuUsageRatio = options.maxCpuUsageRatio || DEFAULT_MAX_CPU_USAGE_RATIO;
-        this.usedCpuCount = this.computeCPUUsageCount(
-          this.maxCpuUsageRatio,
-          options.maxWorkerCount
-        );
-      }
-      /**
-       * Calculates the number of CPU cores to utilize based on available parallelism and constraints.
-       *
-       * @param cpuUsageRatio - Ratio of CPU cores to use (0-1)
-       * @param maxWorkerCount - Optional maximum number of workers
-       * @returns The number of CPU cores to utilize
-       */
-      computeCPUUsageCount(cpuUsageRatio, maxWorkerCount) {
-        const cpuCount = (0, import_node_os.availableParallelism)();
-        const maxWorkers = maxWorkerCount || cpuCount;
-        return Math.min(
-          maxWorkers,
-          Math.max(1, Math.floor(cpuCount * cpuUsageRatio))
-        );
-      }
-      /**
-       * Initializes the cluster by spawning worker processes and setting up signal handlers.
-       * For the primary process, spawns workers and monitors parent process.
-       * For worker processes, executes the worker startup function.
-       *
-       * @throws {Error} If worker is undefined in worker process
-       */
-      async start() {
-        process.on(SIGTERM, this.gracefulClusterShutdown(SIGTERM));
-        process.on(SIGINT, this.gracefulClusterShutdown(SIGINT));
-        if (import_node_cluster.default.isPrimary) {
-          const parentPid = process.ppid;
-          setInterval(() => {
-            try {
-              process.kill(parentPid, 0);
-            } catch (e) {
-              console.log("Parent process has exited.");
-              this.gracefulClusterShutdown(SIGTERM)();
-            }
-          }, 1e3);
-          await this.bootWorkers(this.usedCpuCount);
-        } else {
-          if (!import_node_cluster.default.worker) {
-            throw new Error(
-              "Worker is not defined, it should be defined in worker process"
-            );
-          }
-          this.startOutput = await this.workerStart(
-            import_node_cluster.default.worker,
-            this.usedCpuCount
-          );
-        }
-      }
-      /**
-       * Spawns worker processes and configures their lifecycle event handlers.
-       * Handles worker online, exit and disconnect events.
-       * Automatically restarts failed workers during normal operation.
-       *
-       * @param numWorkers - Number of worker processes to spawn
-       */
-      bootWorkers = async (numWorkers) => {
-        console.info(`Setting ${numWorkers} workers...`);
-        for (let i = 0; i < numWorkers; i++) {
-          import_node_cluster.default.fork();
-        }
-        import_node_cluster.default.on("online", (worker) => {
-          console.info(`worker process ${worker.process.pid} is online`);
-        });
-        import_node_cluster.default.on("exit", (worker, code, signal) => {
-          console.info(
-            `worker ${worker.process.pid} exited with code ${code} and signal ${signal}`
-          );
-          if (!this.shutdownInProgress) {
-            setTimeout(() => import_node_cluster.default.fork(), RESTART_TIME_MS);
-          }
-          if (this.shutdownInProgress && code != 0) {
-            this.hasCleanWorkerExit = false;
-          }
-        });
-        import_node_cluster.default.on("disconnect", (worker) => {
-          console.info(`worker process ${worker.process.pid} has disconnected`);
-        });
-      };
-      /**
-       * Creates a handler function for graceful shutdown on receipt of a signal.
-       * Ensures only one shutdown can occur at a time.
-       * Handles shutdown differently for primary and worker processes.
-       *
-       * @param signal - The signal triggering the shutdown (e.g. SIGTERM)
-       * @returns An async function that performs the shutdown
-       */
-      gracefulClusterShutdown = (signal) => async () => {
-        if (this.shutdownInProgress) {
-          return;
-        }
-        this.shutdownInProgress = true;
-        this.hasCleanWorkerExit = true;
-        console.info(
-          `Got ${signal} on ${this.processStr}. Graceful shutdown start at ${(/* @__PURE__ */ new Date()).toISOString()}`
-        );
-        try {
-          if (import_node_cluster.default.isPrimary) {
-            await this.shutdownWorkers(signal);
-            console.info(`${this.processStr} - worker shutdown successful`);
-            (0, import_node_process.exit)(0);
-          } else {
-            if (this.startOutput) {
-              await this.workerStop(this.startOutput);
-            } else {
-              console.info(
-                `${this.processStr} - shutdown before worker fully started`
-              );
-            }
-            console.info(`${this.processStr} shutdown successful`);
-            this.hasCleanWorkerExit ? (0, import_node_process.exit)(0) : (0, import_node_process.exit)(1);
-          }
-        } catch (e) {
-          console.error(`${this.processStr} - shutdown failed`, e);
-          (0, import_node_process.exit)(1);
-        }
-      };
-      /**
-       * Gracefully terminates all worker processes.
-       * Monitors workers until they all exit or timeout occurs.
-       * Only relevant for the primary process.
-       *
-       * @param signal - The signal to send to worker processes
-       * @returns A promise that resolves when all workers have terminated
-       */
-      shutdownWorkers = (signal) => {
-        return new Promise((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;
-    }
-    const parentDir = import_node_path.default.dirname(currentDir);
-    if (parentDir === currentDir) {
-      break;
+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");
     }
-    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"
+    this.maxCpuUsageRatio = options.maxCpuUsageRatio || DEFAULT_MAX_CPU_USAGE_RATIO;
+    this.usedCpuCount = this.computeCPUUsageCount(
+      this.maxCpuUsageRatio,
+      options.maxWorkerCount
     );
   }
-  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";
-      }
-    };
+  /**
+   * 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/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;
-      }
-      setClickHouseConfig(config) {
-        this.clickhouseConfig = config;
-      }
-      setKafkaConfig(config) {
-        this.kafkaConfig = config;
-      }
-      _env(name) {
-        const value = process.env[name];
-        if (value === void 0) return void 0;
-        const trimmed = value.trim();
-        return trimmed.length > 0 ? trimmed : void 0;
-      }
-      _parseBool(value) {
-        if (value === void 0) return void 0;
-        switch (value.trim().toLowerCase()) {
-          case "1":
-          case "true":
-          case "yes":
-          case "on":
-            return true;
-          case "0":
-          case "false":
-          case "no":
-          case "off":
-            return false;
-          default:
-            return void 0;
-        }
-      }
-      async getClickHouseConfig() {
-        if (this.clickhouseConfig) {
-          return this.clickhouseConfig;
-        }
-        const projectConfig = await readProjectConfig();
-        const envHost = this._env("MOOSE_CLICKHOUSE_CONFIG__HOST");
-        const envPort = this._env("MOOSE_CLICKHOUSE_CONFIG__HOST_PORT");
-        const envUser = this._env("MOOSE_CLICKHOUSE_CONFIG__USER");
-        const envPassword = this._env("MOOSE_CLICKHOUSE_CONFIG__PASSWORD");
-        const envDb = this._env("MOOSE_CLICKHOUSE_CONFIG__DB_NAME");
-        const envUseSSL = this._parseBool(
-          this._env("MOOSE_CLICKHOUSE_CONFIG__USE_SSL")
-        );
-        return {
-          host: envHost ?? projectConfig.clickhouse_config.host,
-          port: envPort ?? projectConfig.clickhouse_config.host_port.toString(),
-          username: envUser ?? projectConfig.clickhouse_config.user,
-          password: envPassword ?? projectConfig.clickhouse_config.password,
-          database: envDb ?? projectConfig.clickhouse_config.db_name,
-          useSSL: envUseSSL !== void 0 ? envUseSSL : projectConfig.clickhouse_config.use_ssl || false
-        };
-      }
-      async getStandaloneClickhouseConfig(overrides) {
-        if (this.clickhouseConfig) {
-          return { ...this.clickhouseConfig, ...overrides };
-        }
-        const envHost = this._env("MOOSE_CLICKHOUSE_CONFIG__HOST");
-        const envPort = this._env("MOOSE_CLICKHOUSE_CONFIG__HOST_PORT");
-        const envUser = this._env("MOOSE_CLICKHOUSE_CONFIG__USER");
-        const envPassword = this._env("MOOSE_CLICKHOUSE_CONFIG__PASSWORD");
-        const envDb = this._env("MOOSE_CLICKHOUSE_CONFIG__DB_NAME");
-        const envUseSSL = this._parseBool(
-          this._env("MOOSE_CLICKHOUSE_CONFIG__USE_SSL")
-        );
-        let projectConfig;
+  /**
+   * 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 {
-          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;
+          process.kill(parentPid, 0);
+        } catch (e) {
+          console.log("Parent process has exited.");
+          this.gracefulClusterShutdown(SIGTERM)();
         }
-        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;
+      }, 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"
+        );
       }
-    };
-    globalThis._mooseConfigRegistry = ConfigurationRegistry.getInstance();
-  }
-});
-
-// src/consumption-apis/standalone.ts
-var standalone_exports = {};
-__export(standalone_exports, {
-  getMooseClients: () => getMooseClients,
-  getMooseUtils: () => getMooseUtils
-});
-async function getMooseUtils(req) {
-  if (req !== void 0) {
-    console.warn(
-      "[DEPRECATED] getMooseUtils(req) no longer requires a request parameter. Use getMooseUtils() instead."
-    );
-  }
-  const runtimeContext = globalThis._mooseRuntimeContext;
-  if (runtimeContext) {
-    return {
-      client: runtimeContext.client,
-      sql,
-      jwt: runtimeContext.jwt
-    };
-  }
-  if (standaloneUtils) {
-    return standaloneUtils;
-  }
-  if (initPromise) {
-    return initPromise;
-  }
-  initPromise = (async () => {
-    await Promise.resolve().then(() => (init_runtime(), runtime_exports));
-    const configRegistry = globalThis._mooseConfigRegistry;
-    if (!configRegistry) {
-      throw new Error(
-        "Moose not initialized. Ensure you're running within a Moose app or have proper configuration set up."
+      this.startOutput = await this.workerStart(
+        import_node_cluster.default.worker,
+        this.usedCpuCount
       );
     }
-    const clickhouseConfig = await configRegistry.getStandaloneClickhouseConfig();
-    const clickhouseClient = getClickhouseClient(
-      toClientConfig(clickhouseConfig)
-    );
-    const queryClient = new QueryClient(clickhouseClient, "standalone");
-    const mooseClient = new MooseClient(queryClient);
-    standaloneUtils = {
-      client: mooseClient,
-      sql,
-      jwt: void 0
-    };
-    return standaloneUtils;
-  })();
-  try {
-    return await initPromise;
-  } finally {
-    initPromise = null;
   }
-}
-async function getMooseClients(config) {
-  console.warn(
-    "[DEPRECATED] getMooseClients() is deprecated. Use getMooseUtils() instead."
-  );
-  if (config && Object.keys(config).length > 0) {
-    await Promise.resolve().then(() => (init_runtime(), runtime_exports));
-    const configRegistry = globalThis._mooseConfigRegistry;
-    if (!configRegistry) {
-      throw new Error(
-        "Configuration registry not initialized. Ensure the Moose framework is properly set up."
+  /**
+   * 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;
     }
-    const clickhouseConfig = await configRegistry.getStandaloneClickhouseConfig(config);
-    const clickhouseClient = getClickhouseClient(
-      toClientConfig(clickhouseConfig)
+    this.shutdownInProgress = true;
+    this.hasCleanWorkerExit = true;
+    console.info(
+      `Got ${signal} on ${this.processStr}. Graceful shutdown start at ${(/* @__PURE__ */ new Date()).toISOString()}`
     );
-    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"
+    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/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) {
+var toClientConfig = (config) => ({
+  ...config,
+  useSSL: config.useSSL ? "true" : "false"
+});
+var createPath = (apisDir, path3) => `${apisDir}${path3}.ts`;
+var httpLogger = (req, res, startMs) => {
+  console.log(
+    `${req.method} ${req.url} ${res.statusCode} ${Date.now() - startMs}ms`
+  );
+};
+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) {
               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);
-                    if (!userFuncModule) {
-                      apiName = pathParts[0];
-                      version = pathParts.slice(1).join("/");
-                    }
-                  }
-                }
+        } 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);
                 if (!userFuncModule) {
-                  if (version) {
-                    const versionedKey = `${apiName}:${version}`;
-                    userFuncModule = apis.get(versionedKey);
-                  } else {
-                    userFuncModule = apis.get(apiName);
-                  }
+                  apiName = pathParts[0];
+                  version = pathParts.slice(1).join("/");
                 }
               }
-              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);
             }
-          }
-          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 (!userFuncModule) {
+              if (version) {
+                const versionedKey = `${apiName}:${version}`;
+                userFuncModule = apis.get(versionedKey);
+              } else {
+                userFuncModule = apis.get(apiName);
+              }
             }
           }
-          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);
+          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);
         }
-      };
-    };
-    createMainRouter = async (publicKey, clickhouseClient, temporalClient, apisDir, enforceAuth, isDmv2, jwtConfig) => {
-      const apiRequestHandler = await apiHandler(
-        publicKey,
-        clickhouseClient,
-        temporalClient,
-        apisDir,
-        enforceAuth,
-        isDmv2,
-        jwtConfig
+      }
+      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()
+        })
       );
-      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;
-        }
-        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");
-            }
-          }
+      return;
+    }
+    let jwtPayload;
+    if (publicKey && jwtConfig) {
+      const jwt = req.headers.authorization?.split(" ")[1];
+      if (jwt) {
+        try {
+          const { payload } = await jose.jwtVerify(jwt, publicKey, {
+            issuer: jwtConfig.issuer,
+            audience: jwtConfig.audience
+          });
+          jwtPayload = payload;
+        } catch (error) {
+          console.log("JWT verification failed for WebApp route");
         }
-        for (const webApp of sortedWebApps) {
-          const mountPath = webApp.config.mountPath || "/";
-          const normalizedMount = mountPath.endsWith("/") && mountPath !== "/" ? mountPath.slice(0, -1) : mountPath;
-          const matches = pathname === normalizedMount || pathname.startsWith(normalizedMount + "/");
-          if (matches) {
-            if (webApp.config.injectMooseUtils !== false) {
-              const { getMooseUtils: getMooseUtils2 } = await Promise.resolve().then(() => (init_standalone(), standalone_exports));
-              req.moose = await getMooseUtils2();
-            }
-            let proxiedUrl = req.url;
-            if (normalizedMount !== "/") {
-              const pathWithoutMount = pathname.substring(normalizedMount.length) || "/";
-              proxiedUrl = pathWithoutMount + url.search;
-            }
-            try {
-              const modifiedReq = Object.assign(
-                Object.create(Object.getPrototypeOf(req)),
-                req,
-                {
-                  url: proxiedUrl
-                }
-              );
-              await webApp.handler(modifiedReq, res);
-              return;
-            } catch (error) {
-              console.error(`Error in WebApp ${webApp.name}:`, error);
-              if (!res.headersSent) {
-                res.writeHead(500, { "Content-Type": "application/json" });
-                res.end(JSON.stringify({ error: "Internal Server Error" }));
-              }
-              return;
-            }
-          }
+      }
+    }
+    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 apiPath = pathname;
-        if (pathname.startsWith("/api/")) {
-          apiPath = pathname.substring(4);
-        } else if (pathname.startsWith("/consumption/")) {
-          apiPath = pathname.substring(13);
+        let proxiedUrl = req.url;
+        if (normalizedMount !== "/") {
+          const pathWithoutMount = pathname.substring(normalizedMount.length) || "/";
+          proxiedUrl = pathWithoutMount + url.search;
         }
-        if (apiPath !== pathname) {
+        try {
           const modifiedReq = Object.assign(
             Object.create(Object.getPrototypeOf(req)),
             req,
             {
-              url: apiPath + url.search
+              url: proxiedUrl
             }
           );
-          await apiRequestHandler(modifiedReq, res);
+          await webApp.handler(modifiedReq, res);
           return;
-        }
-        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");
+        } 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" }));
           }
-          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());
-          });
+          return;
+        }
+      }
+    }
+    let apiPath = pathname;
+    if (pathname.startsWith("/api/")) {
+      apiPath = pathname.substring(4);
+    } else if (pathname.startsWith("/consumption/")) {
+      apiPath = pathname.substring(13);
+    }
+    if (apiPath !== pathname) {
+      const modifiedReq = Object.assign(
+        Object.create(Object.getPrototypeOf(req)),
+        req,
+        {
+          url: apiPath + url.search
         }
+      );
+      await apiRequestHandler(modifiedReq, res);
+      return;
+    }
+    res.writeHead(404, { "Content-Type": "application/json" });
+    res.end(JSON.stringify({ error: "Not Found" }));
+    httpLogger(req, res, start);
+  };
+};
+var runApis = async (config) => {
+  const apisCluster = new Cluster({
+    maxWorkerCount: (config.workerCount ?? 0) > 0 ? config.workerCount : void 0,
+    workerStart: async () => {
+      let temporalClient;
+      if (config.temporalConfig) {
+        temporalClient = await getTemporalClient(
+          config.temporalConfig.url,
+          config.temporalConfig.namespace,
+          config.temporalConfig.clientCert,
+          config.temporalConfig.clientKey,
+          config.temporalConfig.apiKey
+        );
+      }
+      const clickhouseClient = getClickhouseClient(
+        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}`);
       });
-      apisCluster.start();
-    };
-  }
-});
+      return server;
+    },
+    workerStop: async (server) => {
+      return new Promise((resolve2) => {
+        server.close(() => resolve2());
+      });
+    }
+  });
+  apisCluster.start();
+};
 
 // src/clients/redisClient.ts
-var import_redis;
-var init_redisClient = __esm({
-  "src/clients/redisClient.ts"() {
-    "use strict";
-    import_redis = require("redis");
-  }
-});
+var import_redis = require("redis");
+
+// src/consumption-apis/standalone.ts
+init_commons();
+
+// src/utilities/dataParser.ts
+var import_csv_parse = require("csv-parse");
 
 // 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";
 }
@@ -1654,77 +1148,36 @@ 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 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();
-  }
-});
+var CSV_DELIMITERS = {
+  COMMA: ",",
+  TAB: "	",
+  SEMICOLON: ";",
+  PIPE: "|"
+};
+var DEFAULT_CSV_CONFIG = {
+  delimiter: CSV_DELIMITERS.COMMA,
+  columns: true,
+  skipEmptyLines: true,
+  trim: true
+};
 
 // 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 */;
 }
@@ -1961,387 +1414,364 @@ function convertTableConfigToEngineConfig(config) {
   }
   return void 0;
 }
-function findTaskInTree(task, targetName) {
-  if (task.name === targetName) {
-    return task;
-  }
-  if (task.config.onComplete?.length) {
-    for (const childTask of task.config.onComplete) {
-      const found = findTaskInTree(childTask, targetName);
-      if (found) {
-        return found;
+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";
       }
     }
-  }
-  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()
+    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
     };
-    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
-          });
+  });
+  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
         });
-        topics[stream.name] = {
-          name: stream.name,
-          columns: stream.columnArray,
-          targetTable: stream.config.destination?.name,
-          targetTableVersion: stream.config.destination?.config.version,
-          retentionPeriod: stream.config.retentionPeriod ?? defaultRetentionPeriod,
-          partitionCount: stream.config.parallelism ?? 1,
-          version: stream.config.version,
-          transformationTargets,
-          hasMultiTransform: stream._multipleTransformations === void 0,
-          consumers,
-          metadata,
-          lifeCycle: stream.config.lifeCycle,
-          schemaConfig: stream.config.schemaConfig
-        };
       });
-      registry.ingestApis.forEach((api) => {
-        let metadata = api.metadata;
-        if (!metadata && api.config && api.pipelineParent) {
-          metadata = api.pipelineParent.metadata;
-        }
-        ingestApis[api.name] = {
-          name: api.name,
-          columns: api.columnArray,
-          version: api.config.version,
-          path: api.config.path,
-          writeTo: {
-            kind: "stream",
-            name: api.config.destination.name
-          },
-          deadLetterQueue: api.config.deadLetterQueue?.name,
-          metadata,
-          schema: api.schema,
-          allowExtraFields: api.allowExtraFields
-        };
-      });
-      registry.apis.forEach((api, key) => {
-        const rustKey = api.config.version ? `${api.name}:${api.config.version}` : api.name;
-        apis[rustKey] = {
-          name: api.name,
-          queryParams: api.columnArray,
-          responseSchema: api.responseSchema,
-          version: api.config.version,
-          path: api.config.path,
-          metadata: api.metadata
-        };
-      });
-      registry.sqlResources.forEach((sqlResource) => {
-        sqlResources[sqlResource.name] = {
-          name: sqlResource.name,
-          setup: sqlResource.setup,
-          teardown: sqlResource.teardown,
-          sourceFile: sqlResource.sourceFile,
-          sourceLine: sqlResource.sourceLine,
-          sourceColumn: sqlResource.sourceColumn,
-          pullsDataFrom: sqlResource.pullsDataFrom.map((r) => {
-            if (r.kind === "OlapTable") {
-              const table = r;
-              const id = table.config.version ? `${table.name}_${table.config.version}` : table.name;
-              return {
-                id,
-                kind: "Table"
-              };
-            } else if (r.kind === "SqlResource") {
-              const resource = r;
-              return {
-                id: resource.name,
-                kind: "SqlResource"
-              };
-            } else {
-              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
-        };
+    });
+    stream._consumers.forEach((consumer) => {
+      consumers.push({
+        version: consumer.config.version,
+        sourceFile: consumer.config.sourceFile
       });
-      return {
-        topics,
-        tables,
-        ingestApis,
-        apis,
-        sqlResources,
-        workflows,
-        webApps
-      };
+    });
+    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
     };
-    getMooseInternal = () => globalThis.moose_internal;
-    if (getMooseInternal() === void 0) {
-      globalThis.moose_internal = moose_internal;
+  });
+  registry.ingestApis.forEach((api) => {
+    let metadata = api.metadata;
+    if (!metadata && api.config && api.pipelineParent) {
+      metadata = api.pipelineParent.metadata;
     }
-    dumpMooseInternal = async () => {
-      loadIndex();
-      console.log(
-        "___MOOSE_STUFF___start",
-        JSON.stringify(toInfraMap(getMooseInternal())),
-        "end___MOOSE_STUFF___"
-      );
-    };
-    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 });
-      }
+    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
     };
-    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;
+  });
+  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
     };
-    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);
-          }
+  });
+  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}`);
         }
-      });
-      nameToSoleVersionHandler.forEach((handler, name) => {
-        if (!apiFunctions.has(name)) {
-          apiFunctions.set(name, handler);
+      }),
+      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}`);
         }
-      });
-      return apiFunctions;
+      })
     };
-    getWorkflows2 = async () => {
-      loadIndex();
-      const registry = getMooseInternal();
-      return registry.workflows;
+  });
+  registry.workflows.forEach((workflow) => {
+    workflows[workflow.name] = {
+      name: workflow.name,
+      retries: workflow.config.retries,
+      timeout: workflow.config.timeout,
+      schedule: workflow.config.schedule
     };
-    getTaskForWorkflow = async (workflowName, taskName) => {
-      const workflows = await getWorkflows2();
-      const workflow = workflows.get(workflowName);
-      if (!workflow) {
-        throw new Error(`Workflow ${workflowName} not found`);
+  });
+  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
+  };
+};
+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
+        ]);
+      });
+    });
+    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);
       }
-      const task = findTaskInTree(
-        workflow.config.startingTask,
-        taskName
-      );
-      if (!task) {
-        throw new Error(`Task ${taskName} not found in workflow ${workflowName}`);
+      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);
       }
-      return task;
-    };
-    getWebApps2 = async () => {
-      loadIndex();
-      return getMooseInternal().webApps;
-    };
+    }
+  });
+  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;
   }
-});
-
-// src/moose-runner.ts
-var import_ts_node = require("ts-node");
-init_internal();
+  if (task.config.onComplete?.length) {
+    for (const childTask of task.config.onComplete) {
+      const found = findTaskInTree(childTask, targetName);
+      if (found) {
+        return found;
+      }
+    }
+  }
+  return void 0;
+}
+var 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;
+};
+var getWebApps2 = async () => {
+  loadIndex();
+  return getMooseInternal().webApps;
+};
 
 // src/blocks/runner.ts
 var import_fastq = __toESM(require("fastq"));
 init_commons();
 var import_node_fs = __toESM(require("fs"));
-var import_node_path2 = __toESM(require("path"));
+var import_node_path = __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_path2.default.join(dir, file)).isDirectory()) {
-      fileList = walkDir(import_node_path2.default.join(dir, file), fileExtension, fileList);
+    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);
     } else if (file.endsWith(fileExtension)) {
-      fileList.push(import_node_path2.default.join(dir, file));
+      fileList.push(import_node_path.default.join(dir, file));
     }
   });
   return fileList;
@@ -2352,7 +1782,7 @@ var DependencyError = class extends Error {
     this.name = "DependencyError";
   }
 };
-var toClientConfig3 = (config) => ({
+var toClientConfig2 = (config) => ({
   ...config,
   useSSL: config.useSSL ? "true" : "false"
 });
@@ -2404,7 +1834,7 @@ var asyncWorker = async (task) => {
   await createBlocks(task.chClient, task.blocks);
 };
 var runBlocks = async (config) => {
-  const chClient = getClickhouseClient(toClientConfig3(config.clickhouseConfig));
+  const chClient = getClickhouseClient(toClientConfig2(config.clickhouseConfig));
   console.log(`Connected`);
   const blocksFiles = walkDir(config.blocksDir, ".ts", []);
   const numOfBlockFiles = blocksFiles.length;
@@ -2417,10 +1847,10 @@ var runBlocks = async (config) => {
       }
     }
   });
-  for (const path4 of blocksFiles) {
-    console.log(`Adding to queue: ${path4}`);
+  for (const path3 of blocksFiles) {
+    console.log(`Adding to queue: ${path3}`);
     try {
-      const blocks = require(path4).default;
+      const blocks = require(path3).default;
       queue.push({
         chClient,
         blocks,
@@ -2429,7 +1859,7 @@ var runBlocks = async (config) => {
     } catch (err) {
       cliLog({
         action: "Blocks",
-        message: `Failed to import blocks from ${path4}: ${err}`,
+        message: `Failed to import blocks from ${path3}: ${err}`,
         message_type: "Error"
       });
     }
@@ -2439,9 +1869,6 @@ 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");
@@ -2449,9 +1876,6 @@ 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;
@@ -3010,15 +2434,12 @@ async function runApiTypeSerializer(targetModel) {
 
 // src/scripts/runner.ts
 var import_worker2 = require("@temporalio/worker");
-var path3 = __toESM(require("path"));
+var path2 = __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 {
@@ -3303,7 +2724,7 @@ async function registerWorkflows(logger2, config) {
       }
     };
     const workflowBundle = await (0, import_worker2.bundleWorkflowCode)({
-      workflowsPath: path3.resolve(__dirname, "scripts/workflow.js"),
+      workflowsPath: path2.resolve(__dirname, "scripts/workflow.js"),
       logger: silentLogger
     });
     const worker = await import_worker2.Worker.create({