@bayoudhi/moose-lib-serverless 0.7.2 → 0.7.4

package/dist/index.mjs

@@ -4,7 +4,13 @@ var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
 var __getOwnPropNames = Object.getOwnPropertyNames;
 var __getProtoOf = Object.getPrototypeOf;
 var __hasOwnProp = Object.prototype.hasOwnProperty;
-var __commonJS = (cb, mod) => function __require() {
+var __require = /* @__PURE__ */ ((x) => typeof require !== "undefined" ? require : typeof Proxy !== "undefined" ? new Proxy(x, {
+  get: (a, b) => (typeof require !== "undefined" ? require : a)[b]
+}) : x)(function(x) {
+  if (typeof require !== "undefined") return require.apply(this, arguments);
+  throw Error('Dynamic require of "' + x + '" is not supported');
+});
+var __commonJS = (cb, mod) => function __require3() {
   return mod || (0, cb[__getOwnPropNames(cb)[0]])((mod = { exports: {} }).exports, mod), mod.exports;
 };
 var __copyProps = (to, from, except, desc) => {
@@ -180,9 +186,10 @@ var require_confluent_schema_registry = __commonJS({
   }
 });
 
-// ../ts-moose-lib/dist/serverless.mjs
+// ../../node_modules/.pnpm/@514labs+moose-lib@0.6.417_@swc+helpers@0.5.17_esbuild@0.25.12_ts-patch@3.3.0_tsconfig-paths@_suczegg7f7vmuhhhtfsuwrbhmu/node_modules/@514labs/moose-lib/dist/index.mjs
 var import_kafka_javascript = __toESM(require_kafka_javascript(), 1);
 var import_client2 = __toESM(require_client(), 1);
+var import_redis = __toESM(require_redis(), 1);
 import {
   existsSync,
   readdirSync,
@@ -191,16 +198,27 @@ import {
 } from "fs";
 import nodePath from "path";
 import { createClient } from "@clickhouse/client";
-import path from "path";
+import path3 from "path";
 import * as toml from "toml";
 import process2 from "process";
-var import_redis = __toESM(require_redis(), 1);
-import { parse as parse2 } from "csv-parse";
+import * as path2 from "path";
+import { existsSync as existsSync2, readFileSync as readFileSync2 } from "fs";
+import path from "path";
 import { Readable } from "stream";
+import { createHash } from "crypto";
 import { createHash as createHash2 } from "crypto";
-import { createHash as createHash3 } from "crypto";
+import { createHash as createHash3, randomUUID } from "crypto";
+import { performance } from "perf_hooks";
+import * as fs from "fs";
+import { parse as parse2 } from "csv-parse";
 var __defProp2 = Object.defineProperty;
 var __getOwnPropNames2 = Object.getOwnPropertyNames;
+var __require2 = /* @__PURE__ */ ((x) => typeof __require !== "undefined" ? __require : typeof Proxy !== "undefined" ? new Proxy(x, {
+  get: (a, b) => (typeof __require !== "undefined" ? __require : a)[b]
+}) : x)(function(x) {
+  if (typeof __require !== "undefined") return __require.apply(this, arguments);
+  throw Error('Dynamic require of "' + x + '" is not supported');
+});
 var __esm = (fn, res) => function __init() {
   return fn && (res = (0, fn[__getOwnPropNames2(fn)[0]])(fn = 0)), res;
 };
@@ -268,11 +286,11 @@ function walkDirectory(dir, extensions) {
   }
   return results;
 }
-function addJsExtensionToImports(content, fileDir) {
+function addJsExtensionToImports(content2, fileDir) {
   const fromPattern = /(from\s+['"])(\.\.?\/[^'"]*?)(['"])/g;
   const bareImportPattern = /(import\s+['"])(\.\.?\/[^'"]*?)(['"])/g;
   const dynamicPattern = /(import\s*\(\s*['"])(\.\.?\/[^'"]*?)(['"])/g;
-  let result = content;
+  let result = content2;
   result = result.replace(fromPattern, (match, prefix, importPath, quote) => {
     return rewriteImportPath(match, prefix, importPath, quote, fileDir);
   });
@@ -323,10 +341,10 @@ function rewriteImportPath(match, prefix, importPath, quote, fileDir) {
 function rewriteImportExtensions(outDir) {
   const files = walkDirectory(outDir, [".js", ".mjs"]);
   for (const filePath of files) {
-    const content = readFileSync(filePath, "utf-8");
+    const content2 = readFileSync(filePath, "utf-8");
     const fileDir = nodePath.dirname(filePath);
-    const rewritten = addJsExtensionToImports(content, fileDir);
-    if (content !== rewritten) {
+    const rewritten = addJsExtensionToImports(content2, fileDir);
+    if (content2 !== rewritten) {
       writeFileSync(filePath, rewritten, "utf-8");
     }
   }
@@ -378,7 +396,7 @@ var init_commons = __esm({
         console.log(message);
       }
     };
-    antiCachePath = (path2) => `${path2}?num=${Math.random().toString()}&time=${Date.now()}`;
+    antiCachePath = (path4) => `${path4}?num=${Math.random().toString()}&time=${Date.now()}`;
     getFileName = (filePath) => {
       const regex = /\/([^\/]+)\.ts/;
       const matches = filePath.match(regex);
@@ -476,14 +494,14 @@ var init_commons = __esm({
   }
 });
 async function findConfigFile(startDir = process.cwd()) {
-  const fs = await import("fs");
-  let currentDir = path.resolve(startDir);
+  const fs2 = await import("fs");
+  let currentDir = path3.resolve(startDir);
   while (true) {
-    const configPath = path.join(currentDir, "moose.config.toml");
-    if (fs.existsSync(configPath)) {
+    const configPath = path3.join(currentDir, "moose.config.toml");
+    if (fs2.existsSync(configPath)) {
       return configPath;
     }
-    const parentDir = path.dirname(currentDir);
+    const parentDir = path3.dirname(currentDir);
     if (parentDir === currentDir) {
       break;
     }
@@ -492,7 +510,7 @@ async function findConfigFile(startDir = process.cwd()) {
   return null;
 }
 async function readProjectConfig() {
-  const fs = await import("fs");
+  const fs2 = await import("fs");
   const configPath = await findConfigFile();
   if (!configPath) {
     throw new ConfigError(
@@ -500,7 +518,7 @@ async function readProjectConfig() {
     );
   }
   try {
-    const configContent = fs.readFileSync(configPath, "utf-8");
+    const configContent = fs2.readFileSync(configPath, "utf-8");
     const config = toml.parse(configContent);
     return config;
   } catch (error) {
@@ -791,6 +809,7 @@ var ClickHouseEngines = /* @__PURE__ */ ((ClickHouseEngines2) => {
   ClickHouseEngines2["Distributed"] = "Distributed";
   ClickHouseEngines2["IcebergS3"] = "IcebergS3";
   ClickHouseEngines2["Kafka"] = "Kafka";
+  ClickHouseEngines2["Merge"] = "Merge";
   ClickHouseEngines2["ReplicatedMergeTree"] = "ReplicatedMergeTree";
   ClickHouseEngines2["ReplicatedReplacingMergeTree"] = "ReplicatedReplacingMergeTree";
   ClickHouseEngines2["ReplicatedAggregatingMergeTree"] = "ReplicatedAggregatingMergeTree";
@@ -800,50 +819,292 @@ var ClickHouseEngines = /* @__PURE__ */ ((ClickHouseEngines2) => {
   return ClickHouseEngines2;
 })(ClickHouseEngines || {});
 init_commons();
-var MOOSE_RUNTIME_ENV_PREFIX = "__MOOSE_RUNTIME_ENV__:";
-var mooseRuntimeEnv = {
-  /**
-   * Gets a value from an environment variable, with behavior depending on context.
-   *
-   * When IS_LOADING_INFRA_MAP=true (infrastructure loading):
-   *   Returns a marker string that Moose CLI will resolve later
-   *
-   * When IS_LOADING_INFRA_MAP is unset (function/workflow runtime):
-   *   Returns the actual value from the environment variable
-   *
-   * @param envVarName - Name of the environment variable to resolve
-   * @returns Either a marker string or the actual environment variable value
-   * @throws {Error} If the environment variable name is empty
-   * @throws {Error} If the environment variable is not set (runtime mode only)
-   *
-   * @example
-   * ```typescript
-   * // Instead of this (evaluated at build time):
-   * awsAccessKeyId: process.env.AWS_ACCESS_KEY_ID
-   *
-   * // Use this (evaluated at runtime):
-   * awsAccessKeyId: mooseRuntimeEnv.get("AWS_ACCESS_KEY_ID")
-   * ```
-   */
-  get(envVarName) {
-    if (!envVarName || envVarName.trim() === "") {
-      throw new Error("Environment variable name cannot be empty");
+var MOOSE_COMPILER_PLUGINS = [
+  {
+    transform: "./node_modules/@514labs/moose-lib/dist/compilerPlugin.js"
+    // No longer using transformProgram - direct typia integration eliminates
+    // the need for program replacement and the associated incremental compilation issues
+  },
+  {
+    // Keep typia plugin for users who use typia directly (not through Moose resources)
+    transform: "typia/lib/transform"
+  }
+];
+var MOOSE_COMPILER_OPTIONS = {
+  experimentalDecorators: true,
+  esModuleInterop: true,
+  // Disable strict module syntax checking to avoid dual-package type conflicts
+  // This prevents errors where the same type imported with different resolution
+  // modes (CJS vs ESM) is treated as incompatible
+  verbatimModuleSyntax: false
+};
+var MOOSE_MODULE_OPTIONS = {
+  module: "NodeNext",
+  moduleResolution: "NodeNext"
+};
+function getSourceDir() {
+  return process.env.MOOSE_SOURCE_DIR || "app";
+}
+var DEFAULT_OUT_DIR = ".moose/compiled";
+function readUserOutDir(projectRoot = process.cwd()) {
+  try {
+    let content = readFileSync2(
+      path.join(projectRoot, "tsconfig.json"),
+      "utf-8"
+    );
+    if (content.charCodeAt(0) === 65279) {
+      content = content.slice(1);
     }
-    const isLoadingInfraMap = process.env.IS_LOADING_INFRA_MAP === "true";
-    if (isLoadingInfraMap) {
-      return `${MOOSE_RUNTIME_ENV_PREFIX}${envVarName}`;
+    const tsconfig = eval(`(${content})`);
+    return tsconfig.compilerOptions?.outDir || null;
+  } catch {
+    return null;
+  }
+}
+function getOutDir(projectRoot2 = process.cwd()) {
+  const userOutDir = readUserOutDir(projectRoot2);
+  return userOutDir || DEFAULT_OUT_DIR;
+}
+function getCompiledIndexPath(projectRoot2 = process.cwd()) {
+  const outDir = getOutDir(projectRoot2);
+  const sourceDir = getSourceDir();
+  return path.resolve(projectRoot2, outDir, sourceDir, "index.js");
+}
+function hasCompiledArtifacts(projectRoot2 = process.cwd()) {
+  return existsSync2(getCompiledIndexPath(projectRoot2));
+}
+function detectModuleSystem(projectRoot2 = process.cwd()) {
+  const pkgPath = path.join(projectRoot2, "package.json");
+  if (existsSync2(pkgPath)) {
+    try {
+      const pkgContent = readFileSync2(pkgPath, "utf-8");
+      const pkg = JSON.parse(pkgContent);
+      if (pkg.type === "module") {
+        return "esm";
+      }
+    } catch (e) {
+      console.debug(
+        `[moose] Failed to parse package.json at ${pkgPath}, defaulting to CJS:`,
+        e
+      );
+    }
+  }
+  return "cjs";
+}
+function getModuleOptions(moduleSystem) {
+  if (moduleSystem === "esm") {
+    return {
+      module: "ES2022",
+      moduleResolution: "bundler"
+    };
+  }
+  return {
+    module: "CommonJS",
+    moduleResolution: "Node"
+  };
+}
+async function loadModule(modulePath, projectRoot2 = process.cwd()) {
+  const moduleSystem = detectModuleSystem(projectRoot2);
+  if (moduleSystem === "esm") {
+    const { pathToFileURL } = await import("url");
+    const fileUrl = pathToFileURL(modulePath).href;
+    return await import(fileUrl);
+  }
+  return __require2(modulePath);
+}
+var isClientOnlyMode = () => process2.env.MOOSE_CLIENT_ONLY === "true";
+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(),
+  materializedViews: /* @__PURE__ */ new Map(),
+  views: /* @__PURE__ */ new Map()
+};
+var defaultRetentionPeriod = 60 * 60 * 24 * 7;
+var getMooseInternal = () => globalThis.moose_internal;
+if (getMooseInternal() === void 0) {
+  globalThis.moose_internal = moose_internal;
+}
+var loadIndex = async () => {
+  if (!hasCompiledArtifacts()) {
+    const outDir2 = getOutDir();
+    const sourceDir = getSourceDir();
+    throw new Error(
+      `Compiled artifacts not found at ${outDir2}/${sourceDir}/index.js. Run 'npx moose-tspc' to compile your TypeScript first.`
+    );
+  }
+  const registry = getMooseInternal();
+  registry.tables.clear();
+  registry.streams.clear();
+  registry.ingestApis.clear();
+  registry.apis.clear();
+  registry.sqlResources.clear();
+  registry.workflows.clear();
+  registry.webApps.clear();
+  registry.materializedViews.clear();
+  registry.views.clear();
+  const outDir = getOutDir();
+  const compiledDir = path2.isAbsolute(outDir) ? outDir : path2.join(process2.cwd(), outDir);
+  Object.keys(__require2.cache).forEach((key) => {
+    if (key.startsWith(compiledDir)) {
+      delete __require2.cache[key];
+    }
+  });
+  try {
+    const indexPath = getCompiledIndexPath();
+    await loadModule(indexPath);
+  } catch (error) {
+    let hint;
+    let includeDetails = true;
+    const details = error instanceof Error ? error.message : String(error);
+    if (details.includes("no transform has been configured") || details.includes("NoTransformConfigurationError")) {
+      hint = "\u{1F534} Typia Transformation Error\n\nThis is likely a bug in Moose. The Typia type transformer failed to process your code.\n\nPlease report this issue:\n  \u2022 Moose Slack: https://join.slack.com/t/moose-community/shared_invite/zt-2fjh5n3wz-cnOmM9Xe9DYAgQrNu8xKxg\n  \u2022 Include the stack trace below and the file being processed\n\n";
+      includeDetails = false;
+    } else if (details.includes("ERR_REQUIRE_ESM") || details.includes("ES Module")) {
+      hint = "The file or its dependencies are ESM-only. Switch to packages that dual-support CJS & ESM, or upgrade to Node 22.12+. If you must use Node 20, you may try Node 20.19\n\n";
+    }
+    if (hint === void 0) {
+      throw error;
     } else {
-      const value = process.env[envVarName];
-      if (value === void 0) {
-        throw new Error(
-          `Environment variable '${envVarName}' is not set. This is required for runtime execution of functions/workflows.`
-        );
+      const errorMsg = includeDetails ? `${hint}${details}` : hint;
+      const cause = error instanceof Error ? error : void 0;
+      throw new Error(errorMsg, { cause });
+    }
+  }
+};
+var dlqSchema = {
+  version: "3.1",
+  components: {
+    schemas: {
+      DeadLetterModel: {
+        type: "object",
+        properties: {
+          originalRecord: {
+            $ref: "#/components/schemas/Recordstringany"
+          },
+          errorMessage: {
+            type: "string"
+          },
+          errorType: {
+            type: "string"
+          },
+          failedAt: {
+            type: "string",
+            format: "date-time"
+          },
+          source: {
+            oneOf: [
+              {
+                const: "api"
+              },
+              {
+                const: "transform"
+              },
+              {
+                const: "table"
+              }
+            ]
+          }
+        },
+        required: [
+          "originalRecord",
+          "errorMessage",
+          "errorType",
+          "failedAt",
+          "source"
+        ]
+      },
+      Recordstringany: {
+        type: "object",
+        properties: {},
+        required: [],
+        description: "Construct a type with a set of properties K of type T",
+        additionalProperties: {}
       }
-      return value;
     }
+  },
+  schemas: [
+    {
+      $ref: "#/components/schemas/DeadLetterModel"
+    }
+  ]
+};
+var dlqColumns = [
+  {
+    name: "originalRecord",
+    data_type: "Json",
+    primary_key: false,
+    required: true,
+    unique: false,
+    default: null,
+    annotations: [],
+    ttl: null,
+    codec: null,
+    materialized: null,
+    comment: null
+  },
+  {
+    name: "errorMessage",
+    data_type: "String",
+    primary_key: false,
+    required: true,
+    unique: false,
+    default: null,
+    annotations: [],
+    ttl: null,
+    codec: null,
+    materialized: null,
+    comment: null
+  },
+  {
+    name: "errorType",
+    data_type: "String",
+    primary_key: false,
+    required: true,
+    unique: false,
+    default: null,
+    annotations: [],
+    ttl: null,
+    codec: null,
+    materialized: null,
+    comment: null
+  },
+  {
+    name: "failedAt",
+    data_type: "DateTime",
+    primary_key: false,
+    required: true,
+    unique: false,
+    default: null,
+    annotations: [],
+    ttl: null,
+    codec: null,
+    materialized: null,
+    comment: null
+  },
+  {
+    name: "source",
+    data_type: "String",
+    primary_key: false,
+    required: true,
+    unique: false,
+    default: null,
+    annotations: [],
+    ttl: null,
+    codec: null,
+    materialized: null,
+    comment: null
   }
+];
+var getWorkflows = async () => {
+  await loadIndex();
+  const registry = getMooseInternal();
+  return registry.workflows;
 };
-var mooseEnvSecrets = mooseRuntimeEnv;
 var quoteIdentifier = (name) => {
   return name.startsWith("`") && name.endsWith("`") ? name : `\`${name}\``;
 };
@@ -1014,216 +1275,6 @@ var mapToClickHouseType = (value) => {
 function emptyIfUndefined(value) {
   return value === void 0 ? "" : value;
 }
-init_commons();
-function jsonDateReviver(key, value) {
-  const iso8601Format = /^([\+-]?\d{4}(?!\d{2}\b))((-?)((0[1-9]|1[0-2])(\3([12]\d|0[1-9]|3[01]))?|W([0-4]\d|5[0-2])(-?[1-7])?|(00[1-9]|0[1-9]\d|[12]\d{2}|3([0-5]\d|6[1-6])))([T\s]((([01]\d|2[0-3])((:?)[0-5]\d)?|24\:?00)([\.,]\d+(?!:))?)?(\17[0-5]\d([\.,]\d+)?)?([zZ]|([\+-])([01]\d|2[0-3]):?([0-5]\d)?)?)?)$/;
-  if (typeof value === "string" && iso8601Format.test(value)) {
-    return new Date(value);
-  }
-  return value;
-}
-function parseCSV(content, config) {
-  return new Promise((resolve, reject) => {
-    const results = [];
-    parse2(content, {
-      delimiter: config.delimiter,
-      columns: config.columns ?? true,
-      skip_empty_lines: config.skipEmptyLines ?? true,
-      trim: config.trim ?? true
-    }).on("data", (row) => {
-      results.push(row);
-    }).on("end", () => {
-      resolve(results);
-    }).on("error", (error) => {
-      reject(error);
-    });
-  });
-}
-function parseJSON(content, config = {}) {
-  try {
-    const parsed = JSON.parse(content, config.reviver);
-    if (Array.isArray(parsed)) {
-      return parsed;
-    } else {
-      return [parsed];
-    }
-  } catch (error) {
-    throw new Error(
-      `Failed to parse JSON: ${error instanceof Error ? error.message : "Unknown error"}`
-    );
-  }
-}
-function parseJSONWithDates(content) {
-  return parseJSON(content, { reviver: jsonDateReviver });
-}
-function isValidCSVDelimiter(delimiter) {
-  return delimiter.length === 1 && !/\s/.test(delimiter);
-}
-var CSV_DELIMITERS = {
-  COMMA: ",",
-  TAB: "	",
-  SEMICOLON: ";",
-  PIPE: "|"
-};
-var DEFAULT_CSV_CONFIG = {
-  delimiter: CSV_DELIMITERS.COMMA,
-  columns: true,
-  skipEmptyLines: true,
-  trim: true
-};
-var DEFAULT_JSON_CONFIG = {
-  reviver: jsonDateReviver
-};
-var DataSource = class {
-  name;
-  supportsIncremental;
-  constructor(config) {
-    this.name = config.name;
-    this.supportsIncremental = config.supportsIncremental ?? false;
-  }
-};
-init_commons();
-var isClientOnlyMode = () => process2.env.MOOSE_CLIENT_ONLY === "true";
-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(),
-  materializedViews: /* @__PURE__ */ new Map(),
-  views: /* @__PURE__ */ new Map()
-};
-var defaultRetentionPeriod = 60 * 60 * 24 * 7;
-var getMooseInternal = () => globalThis.moose_internal;
-if (getMooseInternal() === void 0) {
-  globalThis.moose_internal = moose_internal;
-}
-var dlqSchema = {
-  version: "3.1",
-  components: {
-    schemas: {
-      DeadLetterModel: {
-        type: "object",
-        properties: {
-          originalRecord: {
-            $ref: "#/components/schemas/Recordstringany"
-          },
-          errorMessage: {
-            type: "string"
-          },
-          errorType: {
-            type: "string"
-          },
-          failedAt: {
-            type: "string",
-            format: "date-time"
-          },
-          source: {
-            oneOf: [
-              {
-                const: "api"
-              },
-              {
-                const: "transform"
-              },
-              {
-                const: "table"
-              }
-            ]
-          }
-        },
-        required: [
-          "originalRecord",
-          "errorMessage",
-          "errorType",
-          "failedAt",
-          "source"
-        ]
-      },
-      Recordstringany: {
-        type: "object",
-        properties: {},
-        required: [],
-        description: "Construct a type with a set of properties K of type T",
-        additionalProperties: {}
-      }
-    }
-  },
-  schemas: [
-    {
-      $ref: "#/components/schemas/DeadLetterModel"
-    }
-  ]
-};
-var dlqColumns = [
-  {
-    name: "originalRecord",
-    data_type: "Json",
-    primary_key: false,
-    required: true,
-    unique: false,
-    default: null,
-    annotations: [],
-    ttl: null,
-    codec: null,
-    materialized: null,
-    comment: null
-  },
-  {
-    name: "errorMessage",
-    data_type: "String",
-    primary_key: false,
-    required: true,
-    unique: false,
-    default: null,
-    annotations: [],
-    ttl: null,
-    codec: null,
-    materialized: null,
-    comment: null
-  },
-  {
-    name: "errorType",
-    data_type: "String",
-    primary_key: false,
-    required: true,
-    unique: false,
-    default: null,
-    annotations: [],
-    ttl: null,
-    codec: null,
-    materialized: null,
-    comment: null
-  },
-  {
-    name: "failedAt",
-    data_type: "DateTime",
-    primary_key: false,
-    required: true,
-    unique: false,
-    default: null,
-    annotations: [],
-    ttl: null,
-    codec: null,
-    materialized: null,
-    comment: null
-  },
-  {
-    name: "source",
-    data_type: "String",
-    primary_key: false,
-    required: true,
-    unique: false,
-    default: null,
-    annotations: [],
-    ttl: null,
-    codec: null,
-    materialized: null,
-    comment: null
-  }
-];
 var OlapTable = class extends TypedBase {
   name;
   /** @internal */
@@ -1295,7 +1346,7 @@ var OlapTable = class extends TypedBase {
   createConfigHash(clickhouseConfig) {
     const effectiveDatabase = this.config.database ?? clickhouseConfig.database;
     const configString = `${clickhouseConfig.host}:${clickhouseConfig.port}:${clickhouseConfig.username}:${clickhouseConfig.password}:${effectiveDatabase}:${clickhouseConfig.useSSL}`;
-    return createHash2("sha256").update(configString).digest("hex").substring(0, 16);
+    return createHash("sha256").update(configString).digest("hex").substring(0, 16);
   }
   /**
    * Gets or creates a memoized ClickHouse client.
@@ -1985,7 +2036,7 @@ var Stream = class extends TypedBase {
       kafkaConfig.securityProtocol,
       kafkaConfig.namespace
     ].join(":");
-    return createHash3("sha256").update(configString).digest("hex").substring(0, 16);
+    return createHash2("sha256").update(configString).digest("hex").substring(0, 16);
   }
   /**
    * Gets or creates a memoized KafkaJS producer using runtime configuration.
@@ -2426,22 +2477,22 @@ var Api = class extends TypedBase {
     return this._handler;
   };
   async call(baseUrl, queryParams) {
-    let path2;
+    let path4;
     if (this.config?.path) {
       if (this.config.version) {
         const pathEndsWithVersion = this.config.path.endsWith(`/${this.config.version}`) || this.config.path === this.config.version || this.config.path.endsWith(this.config.version) && this.config.path.length > this.config.version.length && this.config.path[this.config.path.length - this.config.version.length - 1] === "/";
         if (pathEndsWithVersion) {
-          path2 = this.config.path;
+          path4 = this.config.path;
         } else {
-          path2 = `${this.config.path.replace(/\/$/, "")}/${this.config.version}`;
+          path4 = `${this.config.path.replace(/\/$/, "")}/${this.config.version}`;
         }
       } else {
-        path2 = this.config.path;
+        path4 = this.config.path;
       }
     } else {
-      path2 = this.config?.version ? `${this.name}/${this.config.version}` : this.name;
+      path4 = this.config?.version ? `${this.name}/${this.config.version}` : this.name;
     }
-    const url = new URL(`${baseUrl.replace(/\/$/, "")}/api/${path2}`);
+    const url = new URL(`${baseUrl.replace(/\/$/, "")}/api/${path4}`);
     const searchParams = url.searchParams;
     for (const [key, value] of Object.entries(queryParams)) {
       if (Array.isArray(value)) {
@@ -2500,6 +2551,11 @@ var IngestPipeline = class extends TypedBase {
       }
     }
     if (config.table) {
+      if (typeof config.table === "object" && "engine" in config.table && config.table.engine === "Merge") {
+        throw new Error(
+          `IngestPipeline "${name}": Merge engine is read-only and cannot be used as a table destination.`
+        );
+      }
       const tableConfig = typeof config.table === "object" ? {
         ...config.table,
         lifeCycle: config.table.lifeCycle ?? config.lifeCycle,
@@ -2743,6 +2799,8 @@ var MaterializedView = class {
   sourceTables;
   /** Optional metadata for the materialized view */
   metadata;
+  /** Optional lifecycle management policy for the materialized view */
+  lifeCycle;
   constructor(options, targetSchema, targetColumns) {
     let selectStatement = options.selectStatement;
     if (typeof selectStatement !== "string") {
@@ -2776,6 +2834,7 @@ var MaterializedView = class {
     this.sourceTables = options.selectTables.map(
       (t) => formatTableReference(t)
     );
+    this.lifeCycle = options.lifeCycle;
     this.metadata = options.metadata ? { ...options.metadata } : {};
     if (!this.metadata.source) {
       const stack = new Error().stack;
@@ -3084,6 +3143,675 @@ function getView(name) {
   return getMooseInternal().views.get(name);
 }
 init_commons();
+var MOOSE_RUNTIME_ENV_PREFIX = "__MOOSE_RUNTIME_ENV__:";
+var mooseRuntimeEnv = {
+  /**
+   * Gets a value from an environment variable, with behavior depending on context.
+   *
+   * When IS_LOADING_INFRA_MAP=true (infrastructure loading):
+   *   Returns a marker string that Moose CLI will resolve later
+   *
+   * When IS_LOADING_INFRA_MAP is unset (function/workflow runtime):
+   *   Returns the actual value from the environment variable
+   *
+   * @param envVarName - Name of the environment variable to resolve
+   * @returns Either a marker string or the actual environment variable value
+   * @throws {Error} If the environment variable name is empty
+   * @throws {Error} If the environment variable is not set (runtime mode only)
+   *
+   * @example
+   * ```typescript
+   * // Instead of this (evaluated at build time):
+   * awsAccessKeyId: process.env.AWS_ACCESS_KEY_ID
+   *
+   * // Use this (evaluated at runtime):
+   * awsAccessKeyId: mooseRuntimeEnv.get("AWS_ACCESS_KEY_ID")
+   * ```
+   */
+  get(envVarName) {
+    if (!envVarName || envVarName.trim() === "") {
+      throw new Error("Environment variable name cannot be empty");
+    }
+    const isLoadingInfraMap = process.env.IS_LOADING_INFRA_MAP === "true";
+    if (isLoadingInfraMap) {
+      return `${MOOSE_RUNTIME_ENV_PREFIX}${envVarName}`;
+    } else {
+      const value = process.env[envVarName];
+      if (value === void 0) {
+        throw new Error(
+          `Environment variable '${envVarName}' is not set. This is required for runtime execution of functions/workflows.`
+        );
+      }
+      return value;
+    }
+  }
+};
+var mooseEnvSecrets = mooseRuntimeEnv;
+function formatElapsedTime(ms) {
+  if (ms < 1e3) {
+    return `${Math.round(ms)} ms`;
+  }
+  const seconds = ms / 1e3;
+  if (seconds < 60) {
+    return `${seconds.toFixed(2)} seconds`;
+  }
+  const minutes = Math.floor(seconds / 60);
+  const remainingSeconds = seconds % 60;
+  return `${minutes} minutes and ${remainingSeconds.toFixed(2)} seconds`;
+}
+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 = performance.now();
+    const result = await this.client.query({
+      query,
+      query_params,
+      format: "JSONEachRow",
+      query_id: this.query_id_prefix + 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 = 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 = performance.now();
+    const result = await this.client.command({
+      query,
+      query_params,
+      query_id: this.query_id_prefix + randomUUID()
+    });
+    const elapsedMs = 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: {
+          // Temporal's maximumAttempts = total attempts (initial + retries)
+          maximumAttempts: config.retries + 1
+        },
+        workflowRunTimeout: config.timeout
+      });
+      return {
+        status: 200,
+        body: `Workflow started: ${name}. View it in the Temporal dashboard: http://localhost:8080/namespaces/default/workflows/${workflowId}/${handle.firstExecutionRunId}/history`
+      };
+    } catch (error) {
+      return {
+        status: 400,
+        body: `Error starting workflow: ${error}`
+      };
+    }
+  }
+  async terminate(workflowId) {
+    try {
+      if (!this.client) {
+        return {
+          status: 404,
+          body: `Temporal client not found. Is the feature flag enabled?`
+        };
+      }
+      const handle = this.client.workflow.getHandle(workflowId);
+      await handle.terminate();
+      return {
+        status: 200,
+        body: `Workflow terminated: ${workflowId}`
+      };
+    } catch (error) {
+      return {
+        status: 400,
+        body: `Error terminating workflow: ${error}`
+      };
+    }
+  }
+  async getWorkflowConfig(name) {
+    const workflows = await getWorkflows();
+    const workflow = workflows.get(name);
+    if (workflow) {
+      return {
+        retries: workflow.config.retries || 3,
+        timeout: workflow.config.timeout || "1h"
+      };
+    }
+    throw new Error(`Workflow config not found for ${name}`);
+  }
+  processInputData(name, input_data) {
+    let workflowId = name;
+    if (input_data) {
+      const hash = createHash3("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(
+      `<api> Using temporal_url: ${temporalUrl} and namespace: ${namespace}`
+    );
+    let connectionOptions = {
+      address: temporalUrl,
+      connectTimeout: "3s"
+    };
+    if (clientCert && clientKey) {
+      console.log("Using TLS for secure Temporal");
+      const cert = await fs.readFileSync(clientCert);
+      const key = await fs.readFileSync(clientKey);
+      connectionOptions.tls = {
+        clientCertPair: { crt: cert, key }
+      };
+    } else if (apiKey) {
+      console.log("Using API key for secure Temporal");
+      connectionOptions.address = "us-west1.gcp.api.temporal.io:7233";
+      connectionOptions.apiKey = apiKey;
+      connectionOptions.tls = {};
+      connectionOptions.metadata = {
+        "temporal-namespace": namespace
+      };
+    }
+    console.log(`<api> Connecting to Temporal at ${connectionOptions.address}`);
+    const connection = await import_client2.Connection.connect(connectionOptions);
+    const client = new import_client2.Client({ connection, namespace });
+    console.log("<api> Connected to Temporal server");
+    return client;
+  } catch (error) {
+    console.warn(`Failed to connect to Temporal. Is the feature flag enabled?`);
+    console.warn(error);
+    return void 0;
+  }
+}
+var ApiHelpers = {
+  column: (value) => ["Identifier", value],
+  table: (value) => ["Identifier", value]
+};
+var ConsumptionHelpers = ApiHelpers;
+function joinQueries({
+  values,
+  separator = ",",
+  prefix = "",
+  suffix = ""
+}) {
+  if (values.length === 0) {
+    throw new TypeError(
+      "Expected `join([])` to be called with an array of multiple elements, but got an empty array"
+    );
+  }
+  return new Sql(
+    [prefix, ...Array(values.length - 1).fill(separator), suffix],
+    values
+  );
+}
+function getMooseUtilsFromRequest(req) {
+  console.warn(
+    "[DEPRECATED] getMooseUtilsFromRequest() is deprecated. Import getMooseUtils from '@514labs/moose-lib' and call it without parameters: const { client, sql } = await getMooseUtils();"
+  );
+  return req.moose;
+}
+var getLegacyMooseUtils = getMooseUtilsFromRequest;
+function expressMiddleware() {
+  console.warn(
+    "[DEPRECATED] expressMiddleware() is deprecated. Use getMooseUtils() directly or rely on injectMooseUtils config."
+  );
+  return (req, res, next) => {
+    if (!req.moose && req.raw && req.raw.moose) {
+      req.moose = req.raw.moose;
+    }
+    next();
+  };
+}
+var instance = null;
+var initPromise = null;
+var MooseCache = class _MooseCache {
+  client;
+  isConnected = false;
+  keyPrefix;
+  disconnectTimer = null;
+  idleTimeout;
+  connectPromise = null;
+  constructor() {
+    const redisUrl = process.env.MOOSE_REDIS_CONFIG__URL || "redis://127.0.0.1:6379";
+    const prefix = process.env.MOOSE_REDIS_CONFIG__KEY_PREFIX || "MS";
+    this.idleTimeout = parseInt(process.env.MOOSE_REDIS_CONFIG__IDLE_TIMEOUT || "30", 10) * 1e3;
+    this.keyPrefix = `${prefix}::moosecache::`;
+    this.client = (0, import_redis.createClient)({
+      url: redisUrl
+    });
+    process.on("SIGTERM", this.gracefulShutdown);
+    process.on("SIGINT", this.gracefulShutdown);
+    this.client.on("error", async (err) => {
+      console.error("TS Redis client error:", err);
+      await this.disconnect();
+    });
+    this.client.on("connect", () => {
+      this.isConnected = true;
+      console.log("TS Redis client connected");
+    });
+    this.client.on("end", () => {
+      this.isConnected = false;
+      console.log("TS Redis client disconnected");
+      this.clearDisconnectTimer();
+    });
+  }
+  clearDisconnectTimer() {
+    if (this.disconnectTimer) {
+      clearTimeout(this.disconnectTimer);
+      this.disconnectTimer = null;
+    }
+  }
+  resetDisconnectTimer() {
+    this.clearDisconnectTimer();
+    this.disconnectTimer = setTimeout(async () => {
+      if (this.isConnected) {
+        console.log("TS Redis client disconnecting due to inactivity");
+        await this.disconnect();
+      }
+    }, this.idleTimeout);
+  }
+  async ensureConnected() {
+    if (!this.isConnected) {
+      await this.connect();
+    }
+    this.resetDisconnectTimer();
+  }
+  async connect() {
+    if (this.isConnected) {
+      return;
+    }
+    if (this.connectPromise) {
+      return this.connectPromise;
+    }
+    this.connectPromise = (async () => {
+      try {
+        await this.client.connect();
+        this.resetDisconnectTimer();
+      } catch (error) {
+        this.connectPromise = null;
+        throw error;
+      }
+    })();
+    return this.connectPromise;
+  }
+  async gracefulShutdown() {
+    if (this.isConnected) {
+      await this.disconnect();
+    }
+    process.exit(0);
+  }
+  getPrefixedKey(key) {
+    return `${this.keyPrefix}${key}`;
+  }
+  /**
+   * Gets the singleton instance of MooseCache. Creates a new instance if one doesn't exist.
+   * The client will automatically connect to Redis and handle reconnection if needed.
+   *
+   * @returns Promise<MooseCache> The singleton instance of MooseCache
+   * @example
+   * const cache = await MooseCache.get();
+   */
+  static async get() {
+    if (instance) {
+      return instance;
+    }
+    if (initPromise) {
+      return initPromise;
+    }
+    initPromise = (async () => {
+      try {
+        const newInstance = new _MooseCache();
+        await newInstance.connect();
+        instance = newInstance;
+        return newInstance;
+      } catch (error) {
+        initPromise = null;
+        throw error;
+      }
+    })();
+    return initPromise;
+  }
+  /**
+   * Sets a value in the cache. Objects are automatically JSON stringified.
+   *
+   * @param key - The key to store the value under
+   * @param value - The value to store. Can be a string or any object (will be JSON stringified)
+   * @param ttlSeconds - Optional time-to-live in seconds. If not provided, defaults to 1 hour (3600 seconds).
+   *                    Must be a non-negative number. If 0, the key will expire immediately.
+   * @example
+   * // Store a string
+   * await cache.set("foo", "bar");
+   *
+   * // Store an object with custom TTL
+   * await cache.set("foo:config", { baz: 123, qux: true }, 60); // expires in 1 minute
+   *
+   * // This is essentially a get-set, which returns the previous value if it exists.
+   * // You can create logic to only do work for the first time.
+   * const value = await cache.set("testSessionId", "true");
+   * if (value) {
+   *   // Cache was set before, return
+   * } else {
+   *   // Cache was set for first time, do work
+   * }
+   */
+  async set(key, value, ttlSeconds) {
+    try {
+      if (ttlSeconds !== void 0 && ttlSeconds < 0) {
+        throw new Error("ttlSeconds must be a non-negative number");
+      }
+      await this.ensureConnected();
+      const prefixedKey = this.getPrefixedKey(key);
+      const stringValue = typeof value === "object" ? JSON.stringify(value) : value;
+      const ttl = ttlSeconds ?? 3600;
+      return await this.client.set(prefixedKey, stringValue, {
+        EX: ttl,
+        GET: true
+      });
+    } catch (error) {
+      console.error(`Error setting cache key ${key}:`, error);
+      throw error;
+    }
+  }
+  /**
+   * Retrieves a value from the cache. Attempts to parse the value as JSON if possible.
+   *
+   * @param key - The key to retrieve
+   * @returns Promise<T | null> The value, parsed as type T if it was JSON, or as string if not. Returns null if key doesn't exist
+   * @example
+   * // Get a string
+   * const value = await cache.get("foo");
+   *
+   * // Get and parse an object with type safety
+   * interface Config { baz: number; qux: boolean; }
+   * const config = await cache.get<Config>("foo:config");
+   */
+  async get(key) {
+    try {
+      await this.ensureConnected();
+      const prefixedKey = this.getPrefixedKey(key);
+      const value = await this.client.get(prefixedKey);
+      if (value === null) return null;
+      try {
+        const parsed = JSON.parse(value);
+        if (typeof parsed === "object" && parsed !== null) {
+          return parsed;
+        }
+        return value;
+      } catch {
+        return value;
+      }
+    } catch (error) {
+      console.error(`Error getting cache key ${key}:`, error);
+      throw error;
+    }
+  }
+  /**
+   * Deletes a specific key from the cache.
+   *
+   * @param key - The key to delete
+   * @example
+   * await cache.delete("foo");
+   */
+  async delete(key) {
+    try {
+      await this.ensureConnected();
+      const prefixedKey = this.getPrefixedKey(key);
+      await this.client.del(prefixedKey);
+    } catch (error) {
+      console.error(`Error deleting cache key ${key}:`, error);
+      throw error;
+    }
+  }
+  /**
+   * Deletes all keys that start with the given prefix.
+   *
+   * @param keyPrefix - The prefix of keys to delete
+   * @example
+   * // Delete all keys starting with "foo"
+   * await cache.clearKeys("foo");
+   */
+  async clearKeys(keyPrefix) {
+    try {
+      await this.ensureConnected();
+      const prefixedKey = this.getPrefixedKey(keyPrefix);
+      const keys = await this.client.keys(`${prefixedKey}*`);
+      if (keys.length > 0) {
+        await this.client.del(keys);
+      }
+    } catch (error) {
+      console.error(
+        `Error clearing cache keys with prefix ${keyPrefix}:`,
+        error
+      );
+      throw error;
+    }
+  }
+  /**
+   * Deletes all keys in the cache
+   *
+   * @example
+   * await cache.clear();
+   */
+  async clear() {
+    try {
+      await this.ensureConnected();
+      const keys = await this.client.keys(`${this.keyPrefix}*`);
+      if (keys.length > 0) {
+        await this.client.del(keys);
+      }
+    } catch (error) {
+      console.error("Error clearing cache:", error);
+      throw error;
+    }
+  }
+  /**
+   * Manually disconnects the Redis client. The client will automatically reconnect
+   * when the next operation is performed.
+   *
+   * @example
+   * await cache.disconnect();
+   */
+  async disconnect() {
+    this.clearDisconnectTimer();
+    this.connectPromise = null;
+    if (this.isConnected) {
+      await this.client.quit();
+    }
+  }
+};
+init_commons();
+var standaloneUtils = null;
+var initPromise2 = null;
+var toClientConfig = (config) => ({
+  ...config,
+  useSSL: config.useSSL ? "true" : "false"
+});
+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 (initPromise2) {
+    return initPromise2;
+  }
+  initPromise2 = (async () => {
+    await Promise.resolve().then(() => (init_runtime(), runtime_exports));
+    const configRegistry = globalThis._mooseConfigRegistry;
+    if (!configRegistry) {
+      throw new Error(
+        "Moose not initialized. Ensure you're running within a Moose app or have proper configuration set up."
+      );
+    }
+    const clickhouseConfig = await configRegistry.getStandaloneClickhouseConfig();
+    const clickhouseClient = getClickhouseClient(
+      toClientConfig(clickhouseConfig)
+    );
+    const queryClient = new QueryClient(clickhouseClient, "standalone");
+    const mooseClient = new MooseClient(queryClient);
+    standaloneUtils = {
+      client: mooseClient,
+      sql,
+      jwt: void 0
+    };
+    return standaloneUtils;
+  })();
+  try {
+    return await initPromise2;
+  } finally {
+    initPromise2 = null;
+  }
+}
+async function getMooseClients(config) {
+  console.warn(
+    "[DEPRECATED] getMooseClients() is deprecated. Use getMooseUtils() instead."
+  );
+  if (config && Object.keys(config).length > 0) {
+    await Promise.resolve().then(() => (init_runtime(), runtime_exports));
+    const configRegistry = globalThis._mooseConfigRegistry;
+    if (!configRegistry) {
+      throw new Error(
+        "Configuration registry not initialized. Ensure the Moose framework is properly set up."
+      );
+    }
+    const clickhouseConfig = await configRegistry.getStandaloneClickhouseConfig(config);
+    const clickhouseClient = getClickhouseClient(
+      toClientConfig(clickhouseConfig)
+    );
+    const queryClient = new QueryClient(clickhouseClient, "standalone");
+    const mooseClient = new MooseClient(queryClient);
+    return { client: mooseClient };
+  }
+  const utils = await getMooseUtils();
+  return { client: utils.client };
+}
+function jsonDateReviver(key, value) {
+  const iso8601Format = /^([\+-]?\d{4}(?!\d{2}\b))((-?)((0[1-9]|1[0-2])(\3([12]\d|0[1-9]|3[01]))?|W([0-4]\d|5[0-2])(-?[1-7])?|(00[1-9]|0[1-9]\d|[12]\d{2}|3([0-5]\d|6[1-6])))([T\s]((([01]\d|2[0-3])((:?)[0-5]\d)?|24\:?00)([\.,]\d+(?!:))?)?(\17[0-5]\d([\.,]\d+)?)?([zZ]|([\+-])([01]\d|2[0-3]):?([0-5]\d)?)?)?)$/;
+  if (typeof value === "string" && iso8601Format.test(value)) {
+    return new Date(value);
+  }
+  return value;
+}
+function parseCSV(content2, config) {
+  return new Promise((resolve2, reject) => {
+    const results = [];
+    parse2(content2, {
+      delimiter: config.delimiter,
+      columns: config.columns ?? true,
+      skip_empty_lines: config.skipEmptyLines ?? true,
+      trim: config.trim ?? true
+    }).on("data", (row) => {
+      results.push(row);
+    }).on("end", () => {
+      resolve2(results);
+    }).on("error", (error) => {
+      reject(error);
+    });
+  });
+}
+function parseJSON(content2, config = {}) {
+  try {
+    const parsed = JSON.parse(content2, config.reviver);
+    if (Array.isArray(parsed)) {
+      return parsed;
+    } else {
+      return [parsed];
+    }
+  } catch (error) {
+    throw new Error(
+      `Failed to parse JSON: ${error instanceof Error ? error.message : "Unknown error"}`
+    );
+  }
+}
+function parseJSONWithDates(content2) {
+  return parseJSON(content2, { reviver: jsonDateReviver });
+}
+function isValidCSVDelimiter(delimiter) {
+  return delimiter.length === 1 && !/\s/.test(delimiter);
+}
+var CSV_DELIMITERS = {
+  COMMA: ",",
+  TAB: "	",
+  SEMICOLON: ";",
+  PIPE: "|"
+};
+var DEFAULT_CSV_CONFIG = {
+  delimiter: CSV_DELIMITERS.COMMA,
+  columns: true,
+  skipEmptyLines: true,
+  trim: true
+};
+var DEFAULT_JSON_CONFIG = {
+  reviver: jsonDateReviver
+};
+var DataSource = class {
+  name;
+  supportsIncremental;
+  constructor(config) {
+    this.name = config.name;
+    this.supportsIncremental = config.supportsIncremental ?? false;
+  }
+};
 
 // src/index.ts
 var _pendingClickHouseConfig = null;
@@ -3120,9 +3848,11 @@ function configureClickHouse(config) {
 export {
   ACKs,
   Api,
+  ApiHelpers,
   CSV_DELIMITERS,
   ClickHouseEngines,
   ConsumptionApi,
+  ConsumptionHelpers,
   DEFAULT_CSV_CONFIG,
   DEFAULT_JSON_CONFIG,
   DataSource,
@@ -3136,7 +3866,10 @@ export {
   MAX_RETRY_TIME_MS,
   MOOSE_RUNTIME_ENV_PREFIX,
   MaterializedView,
+  MooseCache,
+  MooseClient,
   OlapTable,
+  QueryClient,
   RETRY_FACTOR_PRODUCER,
   RETRY_INITIAL_TIME_MS,
   Sql,
@@ -3146,24 +3879,35 @@ export {
   View,
   WebApp,
   Workflow,
+  WorkflowClient,
   antiCachePath,
   cliLog,
   compilerLog,
   configureClickHouse,
   createClickhouseParameter,
+  createProducerConfig,
+  expressMiddleware,
   getApi,
   getApis,
+  getClickhouseClient,
   getFileName,
   getIngestApi,
   getIngestApis,
+  getKafkaClient,
+  getKafkaProducer,
+  getLegacyMooseUtils,
   getMaterializedView,
   getMaterializedViews,
+  getMooseClients,
+  getMooseUtils,
+  getMooseUtilsFromRequest,
   getSqlResource,
   getSqlResources,
   getStream,
   getStreams,
   getTable,
   getTables,
+  getTemporalClient,
   getValueFromParameter,
   getView,
   getViews,
@@ -3172,6 +3916,7 @@ export {
   getWorkflow,
   getWorkflows2 as getWorkflows,
   isValidCSVDelimiter,
+  joinQueries,
   logError,
   mapToClickHouseType,
   mapTstoJs,
@@ -3181,6 +3926,7 @@ export {
   parseJSON,
   parseJSONWithDates,
   quoteIdentifier,
+  rewriteImportExtensions,
   sql,
   toQuery,
   toQueryPreview,