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

package/dist/dmv2/index.mjs

@@ -8,247 +8,6 @@ var __export = (target, all) => {
     __defProp(target, name, { get: all[name], enumerable: true });
 };
 
-// src/dmv2/utils/stackTrace.ts
-function shouldSkipStackLine(line) {
-  return line.includes("node_modules") || // Skip npm installed packages (prod)
-  line.includes("node:internal") || // Skip Node.js internals (modern format)
-  line.includes("internal/modules") || // Skip Node.js internals (older format)
-  line.includes("ts-node") || // Skip TypeScript execution
-  line.includes("/ts-moose-lib/src/") || // Skip dev/linked moose-lib src (Unix)
-  line.includes("\\ts-moose-lib\\src\\") || // Skip dev/linked moose-lib src (Windows)
-  line.includes("/ts-moose-lib/dist/") || // Skip dev/linked moose-lib dist (Unix)
-  line.includes("\\ts-moose-lib\\dist\\");
-}
-function parseStackLine(line) {
-  const match = line.match(/\((.*):(\d+):(\d+)\)/) || line.match(/at (.*):(\d+):(\d+)/);
-  if (match && match[1]) {
-    return {
-      file: match[1],
-      line: match[2]
-    };
-  }
-  return void 0;
-}
-function getSourceFileInfo(stack) {
-  if (!stack) return {};
-  const lines = stack.split("\n");
-  for (const line of lines) {
-    if (shouldSkipStackLine(line)) continue;
-    const info = parseStackLine(line);
-    if (info) return info;
-  }
-  return {};
-}
-function getSourceLocationFromStack(stack) {
-  if (!stack) return void 0;
-  const lines = stack.split("\n");
-  for (const line of lines.slice(1)) {
-    if (shouldSkipStackLine(line)) {
-      continue;
-    }
-    const v8Match = line.match(/at\s+(?:.*?\s+\()?(.+):(\d+):(\d+)\)?/);
-    if (v8Match) {
-      return {
-        file: v8Match[1],
-        line: parseInt(v8Match[2], 10),
-        column: parseInt(v8Match[3], 10)
-      };
-    }
-    const smMatch = line.match(/(?:.*@)?(.+):(\d+):(\d+)/);
-    if (smMatch) {
-      return {
-        file: smMatch[1],
-        line: parseInt(smMatch[2], 10),
-        column: parseInt(smMatch[3], 10)
-      };
-    }
-  }
-  return void 0;
-}
-function getSourceFileFromStack(stack) {
-  const location = getSourceLocationFromStack(stack);
-  return location?.file;
-}
-var init_stackTrace = __esm({
-  "src/dmv2/utils/stackTrace.ts"() {
-    "use strict";
-  }
-});
-
-// src/dmv2/typedBase.ts
-var TypedBase;
-var init_typedBase = __esm({
-  "src/dmv2/typedBase.ts"() {
-    "use strict";
-    init_stackTrace();
-    TypedBase = class {
-      /** The JSON schema representation of type T. Injected by the compiler plugin. */
-      schema;
-      /** The name assigned to this resource instance. */
-      name;
-      /** A dictionary mapping column names (keys of T) to their Column definitions. */
-      columns;
-      /** An array containing the Column definitions for this resource. Injected by the compiler plugin. */
-      columnArray;
-      /** The configuration object specific to this resource type. */
-      config;
-      /** Typia validation functions for type T. Injected by the compiler plugin for OlapTable. */
-      validators;
-      /** Optional metadata for the resource, always present as an object. */
-      metadata;
-      /**
-       * Whether this resource allows extra fields beyond the defined columns.
-       * When true, extra fields in payloads are passed through to streaming functions.
-       * Injected by the compiler plugin when the type has an index signature.
-       */
-      allowExtraFields;
-      /**
-       * @internal Constructor intended for internal use by subclasses and the compiler plugin.
-       * It expects the schema and columns to be provided, typically injected by the compiler.
-       *
-       * @param name The name for the resource instance.
-       * @param config The configuration object for the resource.
-       * @param schema The JSON schema for the resource's data type T (injected).
-       * @param columns The array of Column definitions for T (injected).
-       * @param allowExtraFields Whether extra fields are allowed (injected when type has index signature).
-       */
-      constructor(name, config, schema, columns, validators, allowExtraFields) {
-        if (schema === void 0 || columns === void 0) {
-          throw new Error(
-            "Supply the type param T so that the schema is inserted by the compiler plugin."
-          );
-        }
-        this.schema = schema;
-        this.columnArray = columns;
-        const columnsObj = {};
-        columns.forEach((column) => {
-          columnsObj[column.name] = column;
-        });
-        this.columns = columnsObj;
-        this.name = name;
-        this.config = config;
-        this.validators = validators;
-        this.allowExtraFields = allowExtraFields ?? false;
-        this.metadata = config?.metadata ? { ...config.metadata } : {};
-        if (!this.metadata.source) {
-          const stack = new Error().stack;
-          if (stack) {
-            const info = getSourceFileInfo(stack);
-            this.metadata.source = { file: info.file, line: info.line };
-          }
-        }
-      }
-    };
-  }
-});
-
-// src/dataModels/dataModelTypes.ts
-function isArrayNestedType(dt) {
-  return typeof dt === "object" && dt !== null && dt.elementType !== null && typeof dt.elementType === "object" && dt.elementType.hasOwnProperty("columns") && Array.isArray(dt.elementType.columns);
-}
-function isNestedType(dt) {
-  return typeof dt === "object" && dt !== null && Array.isArray(dt.columns);
-}
-var init_dataModelTypes = __esm({
-  "src/dataModels/dataModelTypes.ts"() {
-    "use strict";
-  }
-});
-
-// src/sqlHelpers.ts
-function createClickhouseParameter(parameterIndex, value) {
-  return `{p${parameterIndex}:${mapToClickHouseType(value)}}`;
-}
-function emptyIfUndefined(value) {
-  return value === void 0 ? "" : value;
-}
-var quoteIdentifier, toStaticQuery, toQuery, getValueFromParameter, mapToClickHouseType;
-var init_sqlHelpers = __esm({
-  "src/sqlHelpers.ts"() {
-    "use strict";
-    quoteIdentifier = (name) => {
-      return name.startsWith("`") && name.endsWith("`") ? name : `\`${name}\``;
-    };
-    toStaticQuery = (sql3) => {
-      const [query, params] = toQuery(sql3);
-      if (Object.keys(params).length !== 0) {
-        throw new Error(
-          "Dynamic SQL is not allowed in the select statement in view creation."
-        );
-      }
-      return query;
-    };
-    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];
-    };
-    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
-function dropView(name) {
-  return `DROP VIEW IF EXISTS ${quoteIdentifier(name)}`.trim();
-}
-function createMaterializedView(options) {
-  return `CREATE MATERIALIZED VIEW IF NOT EXISTS ${quoteIdentifier(options.name)}
-        TO ${quoteIdentifier(options.destinationTable)}
-        AS ${options.select}`.trim();
-}
-var init_helpers = __esm({
-  "src/blocks/helpers.ts"() {
-    "use strict";
-    init_sqlHelpers();
-  }
-});
-
-// 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
 var commons_exports = {};
 __export(commons_exports, {
@@ -416,298 +175,6 @@ var init_commons = __esm({
   }
 });
 
-// src/secrets.ts
-var init_secrets = __esm({
-  "src/secrets.ts"() {
-    "use strict";
-  }
-});
-
-// src/consumption-apis/helpers.ts
-import {
-  Client as TemporalClient,
-  Connection
-} from "@temporalio/client";
-import { createHash, randomUUID } from "crypto";
-var init_helpers2 = __esm({
-  "src/consumption-apis/helpers.ts"() {
-    "use strict";
-    init_internal();
-    init_sqlHelpers();
-  }
-});
-
-// 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/cluster-utils.ts
-import cluster from "cluster";
-import { availableParallelism } from "os";
-import { exit } from "process";
-var init_cluster_utils = __esm({
-  "src/cluster-utils.ts"() {
-    "use strict";
-  }
-});
-
-// src/consumption-apis/runner.ts
-import * as jose from "jose";
-var init_runner = __esm({
-  "src/consumption-apis/runner.ts"() {
-    "use strict";
-    init_commons();
-    init_helpers2();
-    init_cluster_utils();
-    init_sqlHelpers();
-    init_internal();
-  }
-});
-
-// src/clients/redisClient.ts
-import { createClient as createClient2 } from "redis";
-var init_redisClient = __esm({
-  "src/clients/redisClient.ts"() {
-    "use strict";
-  }
-});
-
-// src/consumption-apis/standalone.ts
-var init_standalone = __esm({
-  "src/consumption-apis/standalone.ts"() {
-    "use strict";
-    init_helpers2();
-    init_commons();
-    init_sqlHelpers();
-  }
-});
-
-// src/utilities/json.ts
-var init_json = __esm({
-  "src/utilities/json.ts"() {
-    "use strict";
-  }
-});
-
-// src/utilities/dataParser.ts
-import { parse } from "csv-parse";
-var CSV_DELIMITERS, DEFAULT_CSV_CONFIG;
-var init_dataParser = __esm({
-  "src/utilities/dataParser.ts"() {
-    "use strict";
-    init_json();
-    CSV_DELIMITERS = {
-      COMMA: ",",
-      TAB: "	",
-      SEMICOLON: ";",
-      PIPE: "|"
-    };
-    DEFAULT_CSV_CONFIG = {
-      delimiter: CSV_DELIMITERS.COMMA,
-      columns: true,
-      skipEmptyLines: true,
-      trim: true
-    };
-  }
-});
-
-// src/utilities/index.ts
-var init_utilities = __esm({
-  "src/utilities/index.ts"() {
-    "use strict";
-    init_dataParser();
-  }
-});
-
-// src/connectors/dataSource.ts
-var init_dataSource = __esm({
-  "src/connectors/dataSource.ts"() {
-    "use strict";
-  }
-});
-
-// src/index.ts
-var init_index = __esm({
-  "src/index.ts"() {
-    "use strict";
-    init_browserCompatible();
-    init_helpers();
-    init_commons();
-    init_secrets();
-    init_helpers2();
-    init_webAppHelpers();
-    init_task();
-    init_runner();
-    init_redisClient();
-    init_helpers2();
-    init_standalone();
-    init_sqlHelpers();
-    init_utilities();
-    init_dataSource();
-    init_types();
-  }
-});
-
-// src/dmv2/internal.ts
-import process2 from "process";
-var isClientOnlyMode, moose_internal, defaultRetentionPeriod, getMooseInternal, dlqSchema, dlqColumns;
-var init_internal = __esm({
-  "src/dmv2/internal.ts"() {
-    "use strict";
-    init_index();
-    init_commons();
-    isClientOnlyMode = () => process2.env.MOOSE_CLIENT_ONLY === "true";
-    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()
-    };
-    defaultRetentionPeriod = 60 * 60 * 24 * 7;
-    getMooseInternal = () => globalThis.moose_internal;
-    if (getMooseInternal() === void 0) {
-      globalThis.moose_internal = moose_internal;
-    }
-    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"
-        }
-      ]
-    };
-    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
-      }
-    ];
-  }
-});
-
 // src/config/configFile.ts
 import path from "path";
 import * as toml from "toml";
@@ -892,1849 +359,2129 @@ var init_runtime = __esm({
   }
 });
 
-// src/dmv2/sdk/olapTable.ts
-import { Readable } from "stream";
-import { createHash as createHash2 } from "crypto";
-var OlapTable;
-var init_olapTable = __esm({
-  "src/dmv2/sdk/olapTable.ts"() {
-    "use strict";
-    init_typedBase();
-    init_dataModelTypes();
-    init_helpers();
-    init_internal();
-    init_sqlHelpers();
-    OlapTable = class extends TypedBase {
-      name;
-      /** @internal */
-      kind = "OlapTable";
-      /** @internal Memoized ClickHouse client for reusing connections across insert calls */
-      _memoizedClient;
-      /** @internal Hash of the configuration used to create the memoized client */
-      _configHash;
-      /** @internal Cached table name to avoid repeated generation */
-      _cachedTableName;
-      constructor(name, config, schema, columns, validators) {
-        const resolvedConfig = config ? "engine" in config ? config : { ...config, engine: "MergeTree" /* MergeTree */ } : { engine: "MergeTree" /* MergeTree */ };
-        const hasFields = Array.isArray(resolvedConfig.orderByFields) && resolvedConfig.orderByFields.length > 0;
-        const hasExpr = typeof resolvedConfig.orderByExpression === "string" && resolvedConfig.orderByExpression.length > 0;
-        if (hasFields && hasExpr) {
-          throw new Error(
-            `OlapTable ${name}: Provide either orderByFields or orderByExpression, not both.`
-          );
-        }
-        const hasCluster = typeof resolvedConfig.cluster === "string";
-        const hasKeeperPath = typeof resolvedConfig.keeperPath === "string";
-        const hasReplicaName = typeof resolvedConfig.replicaName === "string";
-        if (hasCluster && (hasKeeperPath || hasReplicaName)) {
-          throw new Error(
-            `OlapTable ${name}: Cannot specify both 'cluster' and explicit replication params ('keeperPath' or 'replicaName'). Use 'cluster' for auto-injected params, or use explicit 'keeperPath' and 'replicaName' without 'cluster'.`
-          );
-        }
-        super(name, resolvedConfig, schema, columns, validators);
-        this.name = name;
-        const tables = getMooseInternal().tables;
-        const registryKey = this.config.version ? `${name}_${this.config.version}` : name;
-        if (!isClientOnlyMode() && tables.has(registryKey)) {
-          throw new Error(
-            `OlapTable with name ${name} and version ${config?.version ?? "unversioned"} already exists`
-          );
-        }
-        tables.set(registryKey, this);
-      }
-      /**
-       * Generates the versioned table name following Moose's naming convention
-       * Format: {tableName}_{version_with_dots_replaced_by_underscores}
-       */
-      generateTableName() {
-        if (this._cachedTableName) {
-          return this._cachedTableName;
-        }
-        const tableVersion = this.config.version;
-        if (!tableVersion) {
-          this._cachedTableName = this.name;
-        } else {
-          const versionSuffix = tableVersion.replace(/\./g, "_");
-          this._cachedTableName = `${this.name}_${versionSuffix}`;
-        }
-        return this._cachedTableName;
-      }
-      /**
-       * Creates a fast hash of the ClickHouse configuration.
-       * Uses crypto.createHash for better performance than JSON.stringify.
-       *
-       * @private
-       */
-      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);
-      }
-      /**
-       * Gets or creates a memoized ClickHouse client.
-       * The client is cached and reused across multiple insert calls for better performance.
-       * If the configuration changes, a new client will be created.
-       *
-       * @private
-       */
-      async getMemoizedClient() {
-        await Promise.resolve().then(() => (init_runtime(), runtime_exports));
-        const configRegistry = globalThis._mooseConfigRegistry;
-        const { getClickhouseClient: getClickhouseClient2 } = await Promise.resolve().then(() => (init_commons(), commons_exports));
-        const clickhouseConfig = await configRegistry.getClickHouseConfig();
-        const currentConfigHash = this.createConfigHash(clickhouseConfig);
-        if (this._memoizedClient && this._configHash === currentConfigHash) {
-          return { client: this._memoizedClient, config: clickhouseConfig };
-        }
-        if (this._memoizedClient && this._configHash !== currentConfigHash) {
-          try {
-            await this._memoizedClient.close();
-          } catch (error) {
-          }
-        }
-        const effectiveDatabase = this.config.database ?? clickhouseConfig.database;
-        const client = getClickhouseClient2({
-          username: clickhouseConfig.username,
-          password: clickhouseConfig.password,
-          database: effectiveDatabase,
-          useSSL: clickhouseConfig.useSSL ? "true" : "false",
-          host: clickhouseConfig.host,
-          port: clickhouseConfig.port
-        });
-        this._memoizedClient = client;
-        this._configHash = currentConfigHash;
-        return { client, config: clickhouseConfig };
+// src/dmv2/utils/stackTrace.ts
+function shouldSkipStackLine(line) {
+  return line.includes("node_modules") || // Skip npm installed packages (prod)
+  line.includes("node:internal") || // Skip Node.js internals (modern format)
+  line.includes("internal/modules") || // Skip Node.js internals (older format)
+  line.includes("ts-node") || // Skip TypeScript execution
+  line.includes("/ts-moose-lib/src/") || // Skip dev/linked moose-lib src (Unix)
+  line.includes("\\ts-moose-lib\\src\\") || // Skip dev/linked moose-lib src (Windows)
+  line.includes("/ts-moose-lib/dist/") || // Skip dev/linked moose-lib dist (Unix)
+  line.includes("\\ts-moose-lib\\dist\\");
+}
+function parseStackLine(line) {
+  const match = line.match(/\((.*):(\d+):(\d+)\)/) || line.match(/at (.*):(\d+):(\d+)/);
+  if (match && match[1]) {
+    return {
+      file: match[1],
+      line: match[2]
+    };
+  }
+  return void 0;
+}
+function getSourceFileInfo(stack) {
+  if (!stack) return {};
+  const lines = stack.split("\n");
+  for (const line of lines) {
+    if (shouldSkipStackLine(line)) continue;
+    const info = parseStackLine(line);
+    if (info) return info;
+  }
+  return {};
+}
+function getSourceLocationFromStack(stack) {
+  if (!stack) return void 0;
+  const lines = stack.split("\n");
+  for (const line of lines.slice(1)) {
+    if (shouldSkipStackLine(line)) {
+      continue;
+    }
+    const v8Match = line.match(/at\s+(?:.*?\s+\()?(.+):(\d+):(\d+)\)?/);
+    if (v8Match) {
+      return {
+        file: v8Match[1],
+        line: parseInt(v8Match[2], 10),
+        column: parseInt(v8Match[3], 10)
+      };
+    }
+    const smMatch = line.match(/(?:.*@)?(.+):(\d+):(\d+)/);
+    if (smMatch) {
+      return {
+        file: smMatch[1],
+        line: parseInt(smMatch[2], 10),
+        column: parseInt(smMatch[3], 10)
+      };
+    }
+  }
+  return void 0;
+}
+function getSourceFileFromStack(stack) {
+  const location = getSourceLocationFromStack(stack);
+  return location?.file;
+}
+
+// src/dmv2/typedBase.ts
+var TypedBase = class {
+  /** The JSON schema representation of type T. Injected by the compiler plugin. */
+  schema;
+  /** The name assigned to this resource instance. */
+  name;
+  /** A dictionary mapping column names (keys of T) to their Column definitions. */
+  columns;
+  /** An array containing the Column definitions for this resource. Injected by the compiler plugin. */
+  columnArray;
+  /** The configuration object specific to this resource type. */
+  config;
+  /** Typia validation functions for type T. Injected by the compiler plugin for OlapTable. */
+  validators;
+  /** Optional metadata for the resource, always present as an object. */
+  metadata;
+  /**
+   * Whether this resource allows extra fields beyond the defined columns.
+   * When true, extra fields in payloads are passed through to streaming functions.
+   * Injected by the compiler plugin when the type has an index signature.
+   */
+  allowExtraFields;
+  /**
+   * @internal Constructor intended for internal use by subclasses and the compiler plugin.
+   * It expects the schema and columns to be provided, typically injected by the compiler.
+   *
+   * @param name The name for the resource instance.
+   * @param config The configuration object for the resource.
+   * @param schema The JSON schema for the resource's data type T (injected).
+   * @param columns The array of Column definitions for T (injected).
+   * @param allowExtraFields Whether extra fields are allowed (injected when type has index signature).
+   */
+  constructor(name, config, schema, columns, validators, allowExtraFields) {
+    if (schema === void 0 || columns === void 0) {
+      throw new Error(
+        "Supply the type param T so that the schema is inserted by the compiler plugin."
+      );
+    }
+    this.schema = schema;
+    this.columnArray = columns;
+    const columnsObj = {};
+    columns.forEach((column) => {
+      columnsObj[column.name] = column;
+    });
+    this.columns = columnsObj;
+    this.name = name;
+    this.config = config;
+    this.validators = validators;
+    this.allowExtraFields = allowExtraFields ?? false;
+    this.metadata = config?.metadata ? { ...config.metadata } : {};
+    if (!this.metadata.source) {
+      const stack = new Error().stack;
+      if (stack) {
+        const info = getSourceFileInfo(stack);
+        this.metadata.source = { file: info.file, line: info.line };
       }
-      /**
-       * Closes the memoized ClickHouse client if it exists.
-       * This is useful for cleaning up connections when the table instance is no longer needed.
-       * The client will be automatically recreated on the next insert call if needed.
-       */
-      async closeClient() {
-        if (this._memoizedClient) {
-          try {
-            await this._memoizedClient.close();
-          } catch (error) {
-          } finally {
-            this._memoizedClient = void 0;
-            this._configHash = void 0;
+    }
+  }
+};
+
+// src/dataModels/dataModelTypes.ts
+function isArrayNestedType(dt) {
+  return typeof dt === "object" && dt !== null && dt.elementType !== null && typeof dt.elementType === "object" && dt.elementType.hasOwnProperty("columns") && Array.isArray(dt.elementType.columns);
+}
+function isNestedType(dt) {
+  return typeof dt === "object" && dt !== null && Array.isArray(dt.columns);
+}
+
+// src/sqlHelpers.ts
+var quoteIdentifier = (name) => {
+  return name.startsWith("`") && name.endsWith("`") ? name : `\`${name}\``;
+};
+var toStaticQuery = (sql3) => {
+  const [query, params] = toQuery(sql3);
+  if (Object.keys(params).length !== 0) {
+    throw new Error(
+      "Dynamic SQL is not allowed in the select statement in view creation."
+    );
+  }
+  return query;
+};
+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 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/blocks/helpers.ts
+function dropView(name) {
+  return `DROP VIEW IF EXISTS ${quoteIdentifier(name)}`.trim();
+}
+function createMaterializedView(options) {
+  return `CREATE MATERIALIZED VIEW IF NOT EXISTS ${quoteIdentifier(options.name)}
+        TO ${quoteIdentifier(options.destinationTable)}
+        AS ${options.select}`.trim();
+}
+
+// src/dmv2/internal.ts
+import process2 from "process";
+
+// src/index.ts
+init_commons();
+
+// src/consumption-apis/helpers.ts
+import {
+  Client as TemporalClient,
+  Connection
+} from "@temporalio/client";
+import { createHash, randomUUID } from "crypto";
+
+// src/consumption-apis/runner.ts
+init_commons();
+import * as jose from "jose";
+
+// src/cluster-utils.ts
+import cluster from "cluster";
+import { availableParallelism } from "os";
+import { exit } from "process";
+
+// src/clients/redisClient.ts
+import { createClient as createClient2 } from "redis";
+
+// src/consumption-apis/standalone.ts
+init_commons();
+
+// src/utilities/dataParser.ts
+import { parse } from "csv-parse";
+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();
+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()
+};
+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: {}
       }
-      /**
-       * Validates a single record using typia's comprehensive type checking.
-       * This provides the most accurate validation as it uses the exact TypeScript type information.
-       *
-       * @param record The record to validate
-       * @returns Validation result with detailed error information
-       */
-      validateRecord(record) {
-        if (this.validators?.validate) {
-          try {
-            const result = this.validators.validate(record);
-            return {
-              success: result.success,
-              data: result.data,
-              errors: result.errors?.map(
-                (err) => typeof err === "string" ? err : JSON.stringify(err)
-              )
-            };
-          } catch (error) {
-            return {
-              success: false,
-              errors: [error instanceof Error ? error.message : String(error)]
-            };
-          }
-        }
-        throw new Error("No typia validator found");
+    }
+  },
+  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
+  }
+];
+
+// src/dmv2/sdk/olapTable.ts
+import { Readable } from "stream";
+import { createHash as createHash2 } from "crypto";
+var OlapTable = class extends TypedBase {
+  name;
+  /** @internal */
+  kind = "OlapTable";
+  /** @internal Memoized ClickHouse client for reusing connections across insert calls */
+  _memoizedClient;
+  /** @internal Hash of the configuration used to create the memoized client */
+  _configHash;
+  /** @internal Cached table name to avoid repeated generation */
+  _cachedTableName;
+  constructor(name, config, schema, columns, validators) {
+    const resolvedConfig = config ? "engine" in config ? config : { ...config, engine: "MergeTree" /* MergeTree */ } : { engine: "MergeTree" /* MergeTree */ };
+    const hasFields = Array.isArray(resolvedConfig.orderByFields) && resolvedConfig.orderByFields.length > 0;
+    const hasExpr = typeof resolvedConfig.orderByExpression === "string" && resolvedConfig.orderByExpression.length > 0;
+    if (hasFields && hasExpr) {
+      throw new Error(
+        `OlapTable ${name}: Provide either orderByFields or orderByExpression, not both.`
+      );
+    }
+    const hasCluster = typeof resolvedConfig.cluster === "string";
+    const hasKeeperPath = typeof resolvedConfig.keeperPath === "string";
+    const hasReplicaName = typeof resolvedConfig.replicaName === "string";
+    if (hasCluster && (hasKeeperPath || hasReplicaName)) {
+      throw new Error(
+        `OlapTable ${name}: Cannot specify both 'cluster' and explicit replication params ('keeperPath' or 'replicaName'). Use 'cluster' for auto-injected params, or use explicit 'keeperPath' and 'replicaName' without 'cluster'.`
+      );
+    }
+    super(name, resolvedConfig, schema, columns, validators);
+    this.name = name;
+    const tables = getMooseInternal().tables;
+    const registryKey = this.config.version ? `${name}_${this.config.version}` : name;
+    if (!isClientOnlyMode() && tables.has(registryKey)) {
+      throw new Error(
+        `OlapTable with name ${name} and version ${config?.version ?? "unversioned"} already exists`
+      );
+    }
+    tables.set(registryKey, this);
+  }
+  /**
+   * Generates the versioned table name following Moose's naming convention
+   * Format: {tableName}_{version_with_dots_replaced_by_underscores}
+   */
+  generateTableName() {
+    if (this._cachedTableName) {
+      return this._cachedTableName;
+    }
+    const tableVersion = this.config.version;
+    if (!tableVersion) {
+      this._cachedTableName = this.name;
+    } else {
+      const versionSuffix = tableVersion.replace(/\./g, "_");
+      this._cachedTableName = `${this.name}_${versionSuffix}`;
+    }
+    return this._cachedTableName;
+  }
+  /**
+   * Creates a fast hash of the ClickHouse configuration.
+   * Uses crypto.createHash for better performance than JSON.stringify.
+   *
+   * @private
+   */
+  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);
+  }
+  /**
+   * Gets or creates a memoized ClickHouse client.
+   * The client is cached and reused across multiple insert calls for better performance.
+   * If the configuration changes, a new client will be created.
+   *
+   * @private
+   */
+  async getMemoizedClient() {
+    await Promise.resolve().then(() => (init_runtime(), runtime_exports));
+    const configRegistry = globalThis._mooseConfigRegistry;
+    const { getClickhouseClient: getClickhouseClient2 } = await Promise.resolve().then(() => (init_commons(), commons_exports));
+    const clickhouseConfig = await configRegistry.getClickHouseConfig();
+    const currentConfigHash = this.createConfigHash(clickhouseConfig);
+    if (this._memoizedClient && this._configHash === currentConfigHash) {
+      return { client: this._memoizedClient, config: clickhouseConfig };
+    }
+    if (this._memoizedClient && this._configHash !== currentConfigHash) {
+      try {
+        await this._memoizedClient.close();
+      } catch (error) {
       }
-      /**
-       * Type guard function using typia's is() function.
-       * Provides compile-time type narrowing for TypeScript.
-       *
-       * @param record The record to check
-       * @returns True if record matches type T, with type narrowing
-       */
-      isValidRecord(record) {
-        if (this.validators?.is) {
-          return this.validators.is(record);
-        }
-        throw new Error("No typia validator found");
+    }
+    const effectiveDatabase = this.config.database ?? clickhouseConfig.database;
+    const client = getClickhouseClient2({
+      username: clickhouseConfig.username,
+      password: clickhouseConfig.password,
+      database: effectiveDatabase,
+      useSSL: clickhouseConfig.useSSL ? "true" : "false",
+      host: clickhouseConfig.host,
+      port: clickhouseConfig.port
+    });
+    this._memoizedClient = client;
+    this._configHash = currentConfigHash;
+    return { client, config: clickhouseConfig };
+  }
+  /**
+   * Closes the memoized ClickHouse client if it exists.
+   * This is useful for cleaning up connections when the table instance is no longer needed.
+   * The client will be automatically recreated on the next insert call if needed.
+   */
+  async closeClient() {
+    if (this._memoizedClient) {
+      try {
+        await this._memoizedClient.close();
+      } catch (error) {
+      } finally {
+        this._memoizedClient = void 0;
+        this._configHash = void 0;
       }
-      /**
-       * Assert that a record matches type T, throwing detailed errors if not.
-       * Uses typia's assert() function for the most detailed error reporting.
-       *
-       * @param record The record to assert
-       * @returns The validated and typed record
-       * @throws Detailed validation error if record doesn't match type T
-       */
-      assertValidRecord(record) {
-        if (this.validators?.assert) {
-          return this.validators.assert(record);
-        }
-        throw new Error("No typia validator found");
+    }
+  }
+  /**
+   * Validates a single record using typia's comprehensive type checking.
+   * This provides the most accurate validation as it uses the exact TypeScript type information.
+   *
+   * @param record The record to validate
+   * @returns Validation result with detailed error information
+   */
+  validateRecord(record) {
+    if (this.validators?.validate) {
+      try {
+        const result = this.validators.validate(record);
+        return {
+          success: result.success,
+          data: result.data,
+          errors: result.errors?.map(
+            (err) => typeof err === "string" ? err : JSON.stringify(err)
+          )
+        };
+      } catch (error) {
+        return {
+          success: false,
+          errors: [error instanceof Error ? error.message : String(error)]
+        };
       }
-      /**
-       * Validates an array of records with comprehensive error reporting.
-       * Uses the most appropriate validation method available (typia or basic).
-       *
-       * @param data Array of records to validate
-       * @returns Detailed validation results
-       */
-      async validateRecords(data) {
-        const valid = [];
-        const invalid = [];
-        valid.length = 0;
-        invalid.length = 0;
-        const dataLength = data.length;
-        for (let i = 0; i < dataLength; i++) {
-          const record = data[i];
-          try {
-            if (this.isValidRecord(record)) {
-              valid.push(this.mapToClickhouseRecord(record));
-            } else {
-              const result = this.validateRecord(record);
-              if (result.success) {
-                valid.push(this.mapToClickhouseRecord(record));
-              } else {
-                invalid.push({
-                  record,
-                  error: result.errors?.join(", ") || "Validation failed",
-                  index: i,
-                  path: "root"
-                });
-              }
-            }
-          } catch (error) {
+    }
+    throw new Error("No typia validator found");
+  }
+  /**
+   * Type guard function using typia's is() function.
+   * Provides compile-time type narrowing for TypeScript.
+   *
+   * @param record The record to check
+   * @returns True if record matches type T, with type narrowing
+   */
+  isValidRecord(record) {
+    if (this.validators?.is) {
+      return this.validators.is(record);
+    }
+    throw new Error("No typia validator found");
+  }
+  /**
+   * Assert that a record matches type T, throwing detailed errors if not.
+   * Uses typia's assert() function for the most detailed error reporting.
+   *
+   * @param record The record to assert
+   * @returns The validated and typed record
+   * @throws Detailed validation error if record doesn't match type T
+   */
+  assertValidRecord(record) {
+    if (this.validators?.assert) {
+      return this.validators.assert(record);
+    }
+    throw new Error("No typia validator found");
+  }
+  /**
+   * Validates an array of records with comprehensive error reporting.
+   * Uses the most appropriate validation method available (typia or basic).
+   *
+   * @param data Array of records to validate
+   * @returns Detailed validation results
+   */
+  async validateRecords(data) {
+    const valid = [];
+    const invalid = [];
+    valid.length = 0;
+    invalid.length = 0;
+    const dataLength = data.length;
+    for (let i = 0; i < dataLength; i++) {
+      const record = data[i];
+      try {
+        if (this.isValidRecord(record)) {
+          valid.push(this.mapToClickhouseRecord(record));
+        } else {
+          const result = this.validateRecord(record);
+          if (result.success) {
+            valid.push(this.mapToClickhouseRecord(record));
+          } else {
             invalid.push({
               record,
-              error: error instanceof Error ? error.message : String(error),
+              error: result.errors?.join(", ") || "Validation failed",
               index: i,
               path: "root"
             });
           }
         }
-        return {
-          valid,
-          invalid,
-          total: dataLength
-        };
+      } catch (error) {
+        invalid.push({
+          record,
+          error: error instanceof Error ? error.message : String(error),
+          index: i,
+          path: "root"
+        });
       }
-      /**
-       * Optimized batch retry that minimizes individual insert operations.
-       * Groups records into smaller batches to reduce round trips while still isolating failures.
-       *
-       * @private
-       */
-      async retryIndividualRecords(client, tableName, records) {
-        const successful = [];
-        const failed = [];
-        const RETRY_BATCH_SIZE = 10;
-        const totalRecords = records.length;
-        for (let i = 0; i < totalRecords; i += RETRY_BATCH_SIZE) {
-          const batchEnd = Math.min(i + RETRY_BATCH_SIZE, totalRecords);
-          const batch = records.slice(i, batchEnd);
+    }
+    return {
+      valid,
+      invalid,
+      total: dataLength
+    };
+  }
+  /**
+   * Optimized batch retry that minimizes individual insert operations.
+   * Groups records into smaller batches to reduce round trips while still isolating failures.
+   *
+   * @private
+   */
+  async retryIndividualRecords(client, tableName, records) {
+    const successful = [];
+    const failed = [];
+    const RETRY_BATCH_SIZE = 10;
+    const totalRecords = records.length;
+    for (let i = 0; i < totalRecords; i += RETRY_BATCH_SIZE) {
+      const batchEnd = Math.min(i + RETRY_BATCH_SIZE, totalRecords);
+      const batch = records.slice(i, batchEnd);
+      try {
+        await client.insert({
+          table: quoteIdentifier(tableName),
+          values: batch,
+          format: "JSONEachRow",
+          clickhouse_settings: {
+            date_time_input_format: "best_effort",
+            // Add performance settings for retries
+            max_insert_block_size: RETRY_BATCH_SIZE,
+            max_block_size: RETRY_BATCH_SIZE
+          }
+        });
+        successful.push(...batch);
+      } catch (batchError) {
+        for (let j = 0; j < batch.length; j++) {
+          const record = batch[j];
           try {
             await client.insert({
               table: quoteIdentifier(tableName),
-              values: batch,
+              values: [record],
               format: "JSONEachRow",
               clickhouse_settings: {
-                date_time_input_format: "best_effort",
-                // Add performance settings for retries
-                max_insert_block_size: RETRY_BATCH_SIZE,
-                max_block_size: RETRY_BATCH_SIZE
+                date_time_input_format: "best_effort"
               }
             });
-            successful.push(...batch);
-          } catch (batchError) {
-            for (let j = 0; j < batch.length; j++) {
-              const record = batch[j];
-              try {
-                await client.insert({
-                  table: quoteIdentifier(tableName),
-                  values: [record],
-                  format: "JSONEachRow",
-                  clickhouse_settings: {
-                    date_time_input_format: "best_effort"
-                  }
-                });
-                successful.push(record);
-              } catch (error) {
-                failed.push({
-                  record,
-                  error: error instanceof Error ? error.message : String(error),
-                  index: i + j
-                });
-              }
-            }
-          }
-        }
-        return { successful, failed };
-      }
-      /**
-       * Validates input parameters and strategy compatibility
-       * @private
-       */
-      validateInsertParameters(data, options) {
-        const isStream = data instanceof Readable;
-        const strategy = options?.strategy || "fail-fast";
-        const shouldValidate = options?.validate !== false;
-        if (isStream && strategy === "isolate") {
-          throw new Error(
-            "The 'isolate' error strategy is not supported with stream input. Use 'fail-fast' or 'discard' instead."
-          );
-        }
-        if (isStream && shouldValidate) {
-          console.warn(
-            "Validation is not supported with stream input. Validation will be skipped."
-          );
-        }
-        return { isStream, strategy, shouldValidate };
-      }
-      /**
-       * Handles early return cases for empty data
-       * @private
-       */
-      handleEmptyData(data, isStream) {
-        if (isStream && !data) {
-          return {
-            successful: 0,
-            failed: 0,
-            total: 0
-          };
-        }
-        if (!isStream && (!data || data.length === 0)) {
-          return {
-            successful: 0,
-            failed: 0,
-            total: 0
-          };
-        }
-        return null;
-      }
-      /**
-       * Performs pre-insertion validation for array data
-       * @private
-       */
-      async performPreInsertionValidation(data, shouldValidate, strategy, options) {
-        if (!shouldValidate) {
-          return { validatedData: data, validationErrors: [] };
-        }
-        try {
-          const validationResult = await this.validateRecords(data);
-          const validatedData = validationResult.valid;
-          const validationErrors = validationResult.invalid;
-          if (validationErrors.length > 0) {
-            this.handleValidationErrors(validationErrors, strategy, data, options);
-            switch (strategy) {
-              case "discard":
-                return { validatedData, validationErrors };
-              case "isolate":
-                return { validatedData: data, validationErrors };
-              default:
-                return { validatedData, validationErrors };
-            }
-          }
-          return { validatedData, validationErrors };
-        } catch (validationError) {
-          if (strategy === "fail-fast") {
-            throw validationError;
-          }
-          console.warn("Validation error:", validationError);
-          return { validatedData: data, validationErrors: [] };
-        }
-      }
-      /**
-       * Handles validation errors based on the specified strategy
-       * @private
-       */
-      handleValidationErrors(validationErrors, strategy, data, options) {
-        switch (strategy) {
-          case "fail-fast":
-            const firstError = validationErrors[0];
-            throw new Error(
-              `Validation failed for record at index ${firstError.index}: ${firstError.error}`
-            );
-          case "discard":
-            this.checkValidationThresholds(validationErrors, data.length, options);
-            break;
-          case "isolate":
-            break;
-        }
-      }
-      /**
-       * Checks if validation errors exceed configured thresholds
-       * @private
-       */
-      checkValidationThresholds(validationErrors, totalRecords, options) {
-        const validationFailedCount = validationErrors.length;
-        const validationFailedRatio = validationFailedCount / totalRecords;
-        if (options?.allowErrors !== void 0 && validationFailedCount > options.allowErrors) {
-          throw new Error(
-            `Too many validation failures: ${validationFailedCount} > ${options.allowErrors}. Errors: ${validationErrors.map((e) => e.error).join(", ")}`
-          );
-        }
-        if (options?.allowErrorsRatio !== void 0 && validationFailedRatio > options.allowErrorsRatio) {
-          throw new Error(
-            `Validation failure ratio too high: ${validationFailedRatio.toFixed(3)} > ${options.allowErrorsRatio}. Errors: ${validationErrors.map((e) => e.error).join(", ")}`
-          );
-        }
-      }
-      /**
-       * Optimized insert options preparation with better memory management
-       * @private
-       */
-      prepareInsertOptions(tableName, data, validatedData, isStream, strategy, options) {
-        const insertOptions = {
-          table: quoteIdentifier(tableName),
-          format: "JSONEachRow",
-          clickhouse_settings: {
-            date_time_input_format: "best_effort",
-            wait_end_of_query: 1,
-            // Ensure at least once delivery for INSERT operations
-            // Performance optimizations
-            max_insert_block_size: isStream ? 1e5 : Math.min(validatedData.length, 1e5),
-            max_block_size: 65536,
-            // Use async inserts for better performance with large datasets
-            async_insert: validatedData.length > 1e3 ? 1 : 0,
-            wait_for_async_insert: 1
-            // For at least once delivery
-          }
-        };
-        if (isStream) {
-          insertOptions.values = data;
-        } else {
-          insertOptions.values = validatedData;
-        }
-        if (strategy === "discard" && (options?.allowErrors !== void 0 || options?.allowErrorsRatio !== void 0)) {
-          if (options.allowErrors !== void 0) {
-            insertOptions.clickhouse_settings.input_format_allow_errors_num = options.allowErrors;
-          }
-          if (options.allowErrorsRatio !== void 0) {
-            insertOptions.clickhouse_settings.input_format_allow_errors_ratio = options.allowErrorsRatio;
+            successful.push(record);
+          } catch (error) {
+            failed.push({
+              record,
+              error: error instanceof Error ? error.message : String(error),
+              index: i + j
+            });
           }
         }
-        return insertOptions;
       }
-      /**
-       * Creates success result for completed insertions
-       * @private
-       */
-      createSuccessResult(data, validatedData, validationErrors, isStream, shouldValidate, strategy) {
-        if (isStream) {
-          return {
-            successful: -1,
-            // -1 indicates stream mode where count is unknown
-            failed: 0,
-            total: -1
-          };
-        }
-        const insertedCount = validatedData.length;
-        const totalProcessed = shouldValidate ? data.length : insertedCount;
-        const result = {
-          successful: insertedCount,
-          failed: shouldValidate ? validationErrors.length : 0,
-          total: totalProcessed
-        };
-        if (shouldValidate && validationErrors.length > 0 && strategy === "discard") {
-          result.failedRecords = validationErrors.map((ve) => ({
-            record: ve.record,
-            error: `Validation error: ${ve.error}`,
-            index: ve.index
-          }));
-        }
-        return result;
-      }
-      /**
-       * Handles insertion errors based on the specified strategy
-       * @private
-       */
-      async handleInsertionError(batchError, strategy, tableName, data, validatedData, validationErrors, isStream, shouldValidate, options) {
+    }
+    return { successful, failed };
+  }
+  /**
+   * Validates input parameters and strategy compatibility
+   * @private
+   */
+  validateInsertParameters(data, options) {
+    const isStream = data instanceof Readable;
+    const strategy = options?.strategy || "fail-fast";
+    const shouldValidate = options?.validate !== false;
+    if (isStream && strategy === "isolate") {
+      throw new Error(
+        "The 'isolate' error strategy is not supported with stream input. Use 'fail-fast' or 'discard' instead."
+      );
+    }
+    if (isStream && shouldValidate) {
+      console.warn(
+        "Validation is not supported with stream input. Validation will be skipped."
+      );
+    }
+    return { isStream, strategy, shouldValidate };
+  }
+  /**
+   * Handles early return cases for empty data
+   * @private
+   */
+  handleEmptyData(data, isStream) {
+    if (isStream && !data) {
+      return {
+        successful: 0,
+        failed: 0,
+        total: 0
+      };
+    }
+    if (!isStream && (!data || data.length === 0)) {
+      return {
+        successful: 0,
+        failed: 0,
+        total: 0
+      };
+    }
+    return null;
+  }
+  /**
+   * Performs pre-insertion validation for array data
+   * @private
+   */
+  async performPreInsertionValidation(data, shouldValidate, strategy, options) {
+    if (!shouldValidate) {
+      return { validatedData: data, validationErrors: [] };
+    }
+    try {
+      const validationResult = await this.validateRecords(data);
+      const validatedData = validationResult.valid;
+      const validationErrors = validationResult.invalid;
+      if (validationErrors.length > 0) {
+        this.handleValidationErrors(validationErrors, strategy, data, options);
         switch (strategy) {
-          case "fail-fast":
-            throw new Error(
-              `Failed to insert data into table ${tableName}: ${batchError}`
-            );
           case "discard":
-            throw new Error(
-              `Too many errors during insert into table ${tableName}. Error threshold exceeded: ${batchError}`
-            );
+            return { validatedData, validationErrors };
           case "isolate":
-            return await this.handleIsolateStrategy(
-              batchError,
-              tableName,
-              data,
-              validatedData,
-              validationErrors,
-              isStream,
-              shouldValidate,
-              options
-            );
+            return { validatedData: data, validationErrors };
           default:
-            throw new Error(`Unknown error strategy: ${strategy}`);
+            return { validatedData, validationErrors };
         }
       }
-      /**
-       * Handles the isolate strategy for insertion errors
-       * @private
-       */
-      async handleIsolateStrategy(batchError, tableName, data, validatedData, validationErrors, isStream, shouldValidate, options) {
-        if (isStream) {
-          throw new Error(
-            `Isolate strategy is not supported with stream input: ${batchError}`
-          );
-        }
-        try {
-          const { client } = await this.getMemoizedClient();
-          const skipValidationOnRetry = options?.skipValidationOnRetry || false;
-          const retryData = skipValidationOnRetry ? data : validatedData;
-          const { successful, failed } = await this.retryIndividualRecords(
-            client,
-            tableName,
-            retryData
-          );
-          const allFailedRecords = [
-            // Validation errors (if any and not skipping validation on retry)
-            ...shouldValidate && !skipValidationOnRetry ? validationErrors.map((ve) => ({
-              record: ve.record,
-              error: `Validation error: ${ve.error}`,
-              index: ve.index
-            })) : [],
-            // Insertion errors
-            ...failed
-          ];
-          this.checkInsertionThresholds(
-            allFailedRecords,
-            data.length,
-            options
-          );
-          return {
-            successful: successful.length,
-            failed: allFailedRecords.length,
-            total: data.length,
-            failedRecords: allFailedRecords
-          };
-        } catch (isolationError) {
-          throw new Error(
-            `Failed to insert data into table ${tableName} during record isolation: ${isolationError}`
-          );
-        }
+      return { validatedData, validationErrors };
+    } catch (validationError) {
+      if (strategy === "fail-fast") {
+        throw validationError;
       }
-      /**
-       * Checks if insertion errors exceed configured thresholds
-       * @private
-       */
-      checkInsertionThresholds(failedRecords, totalRecords, options) {
-        const totalFailed = failedRecords.length;
-        const failedRatio = totalFailed / totalRecords;
-        if (options?.allowErrors !== void 0 && totalFailed > options.allowErrors) {
-          throw new Error(
-            `Too many failed records: ${totalFailed} > ${options.allowErrors}. Failed records: ${failedRecords.map((f) => f.error).join(", ")}`
-          );
-        }
-        if (options?.allowErrorsRatio !== void 0 && failedRatio > options.allowErrorsRatio) {
-          throw new Error(
-            `Failed record ratio too high: ${failedRatio.toFixed(3)} > ${options.allowErrorsRatio}. Failed records: ${failedRecords.map((f) => f.error).join(", ")}`
-          );
-        }
+      console.warn("Validation error:", validationError);
+      return { validatedData: data, validationErrors: [] };
+    }
+  }
+  /**
+   * Handles validation errors based on the specified strategy
+   * @private
+   */
+  handleValidationErrors(validationErrors, strategy, data, options) {
+    switch (strategy) {
+      case "fail-fast":
+        const firstError = validationErrors[0];
+        throw new Error(
+          `Validation failed for record at index ${firstError.index}: ${firstError.error}`
+        );
+      case "discard":
+        this.checkValidationThresholds(validationErrors, data.length, options);
+        break;
+      case "isolate":
+        break;
+    }
+  }
+  /**
+   * Checks if validation errors exceed configured thresholds
+   * @private
+   */
+  checkValidationThresholds(validationErrors, totalRecords, options) {
+    const validationFailedCount = validationErrors.length;
+    const validationFailedRatio = validationFailedCount / totalRecords;
+    if (options?.allowErrors !== void 0 && validationFailedCount > options.allowErrors) {
+      throw new Error(
+        `Too many validation failures: ${validationFailedCount} > ${options.allowErrors}. Errors: ${validationErrors.map((e) => e.error).join(", ")}`
+      );
+    }
+    if (options?.allowErrorsRatio !== void 0 && validationFailedRatio > options.allowErrorsRatio) {
+      throw new Error(
+        `Validation failure ratio too high: ${validationFailedRatio.toFixed(3)} > ${options.allowErrorsRatio}. Errors: ${validationErrors.map((e) => e.error).join(", ")}`
+      );
+    }
+  }
+  /**
+   * Optimized insert options preparation with better memory management
+   * @private
+   */
+  prepareInsertOptions(tableName, data, validatedData, isStream, strategy, options) {
+    const insertOptions = {
+      table: quoteIdentifier(tableName),
+      format: "JSONEachRow",
+      clickhouse_settings: {
+        date_time_input_format: "best_effort",
+        wait_end_of_query: 1,
+        // Ensure at least once delivery for INSERT operations
+        // Performance optimizations
+        max_insert_block_size: isStream ? 1e5 : Math.min(validatedData.length, 1e5),
+        max_block_size: 65536,
+        // Use async inserts for better performance with large datasets
+        async_insert: validatedData.length > 1e3 ? 1 : 0,
+        wait_for_async_insert: 1
+        // For at least once delivery
       }
-      /**
-       * Recursively transforms a record to match ClickHouse's JSONEachRow requirements
-       *
-       * - For every Array(Nested(...)) field at any depth, each item is wrapped in its own array and recursively processed.
-       * - For every Nested struct (not array), it recurses into the struct.
-       * - This ensures compatibility with kafka_clickhouse_sync
-       *
-       * @param record The input record to transform (may be deeply nested)
-       * @param columns The schema columns for this level (defaults to this.columnArray at the top level)
-       * @returns The transformed record, ready for ClickHouse JSONEachRow insertion
-       */
-      mapToClickhouseRecord(record, columns = this.columnArray) {
-        const result = { ...record };
-        for (const col of columns) {
-          const value = record[col.name];
-          const dt = col.data_type;
-          if (isArrayNestedType(dt)) {
-            if (Array.isArray(value) && (value.length === 0 || typeof value[0] === "object")) {
-              result[col.name] = value.map((item) => [
-                this.mapToClickhouseRecord(item, dt.elementType.columns)
-              ]);
-            }
-          } else if (isNestedType(dt)) {
-            if (value && typeof value === "object") {
-              result[col.name] = this.mapToClickhouseRecord(value, dt.columns);
-            }
-          }
-        }
-        return result;
+    };
+    if (isStream) {
+      insertOptions.values = data;
+    } else {
+      insertOptions.values = validatedData;
+    }
+    if (strategy === "discard" && (options?.allowErrors !== void 0 || options?.allowErrorsRatio !== void 0)) {
+      if (options.allowErrors !== void 0) {
+        insertOptions.clickhouse_settings.input_format_allow_errors_num = options.allowErrors;
       }
-      /**
-       * Inserts data directly into the ClickHouse table with enhanced error handling and validation.
-       * This method establishes a direct connection to ClickHouse using the project configuration
-       * and inserts the provided data into the versioned table.
-       *
-       * PERFORMANCE OPTIMIZATIONS:
-       * - Memoized client connections with fast config hashing
-       * - Single-pass validation with pre-allocated arrays
-       * - Batch-optimized retry strategy (batches of 10, then individual)
-       * - Optimized ClickHouse settings for large datasets
-       * - Reduced memory allocations and object creation
-       *
-       * Uses advanced typia validation when available for comprehensive type checking,
-       * with fallback to basic validation for compatibility.
-       *
-       * The ClickHouse client is memoized and reused across multiple insert calls for better performance.
-       * If the configuration changes, a new client will be automatically created.
-       *
-       * @param data Array of objects conforming to the table schema, or a Node.js Readable stream
-       * @param options Optional configuration for error handling, validation, and insertion behavior
-       * @returns Promise resolving to detailed insertion results
-       * @throws {ConfigError} When configuration cannot be read or parsed
-       * @throws {ClickHouseError} When insertion fails based on the error strategy
-       * @throws {ValidationError} When validation fails and strategy is 'fail-fast'
-       *
-       * @example
-       * ```typescript
-       * // Create an OlapTable instance (typia validators auto-injected)
-       * const userTable = new OlapTable<User>('users');
-       *
-       * // Insert with comprehensive typia validation
-       * const result1 = await userTable.insert([
-       *   { id: 1, name: 'John', email: 'john@example.com' },
-       *   { id: 2, name: 'Jane', email: 'jane@example.com' }
-       * ]);
-       *
-       * // Insert data with stream input (validation not available for streams)
-       * const dataStream = new Readable({
-       *   objectMode: true,
-       *   read() { // Stream implementation }
-       * });
-       * const result2 = await userTable.insert(dataStream, { strategy: 'fail-fast' });
-       *
-       * // Insert with validation disabled for performance
-       * const result3 = await userTable.insert(data, { validate: false });
-       *
-       * // Insert with error handling strategies
-       * const result4 = await userTable.insert(mixedData, {
-       *   strategy: 'isolate',
-       *   allowErrorsRatio: 0.1,
-       *   validate: true  // Use typia validation (default)
-       * });
-       *
-       * // Optional: Clean up connection when completely done
-       * await userTable.closeClient();
-       * ```
-       */
-      async insert(data, options) {
-        const { isStream, strategy, shouldValidate } = this.validateInsertParameters(data, options);
-        const emptyResult = this.handleEmptyData(data, isStream);
-        if (emptyResult) {
-          return emptyResult;
-        }
-        let validatedData = [];
-        let validationErrors = [];
-        if (!isStream && shouldValidate) {
-          const validationResult = await this.performPreInsertionValidation(
-            data,
-            shouldValidate,
-            strategy,
-            options
-          );
-          validatedData = validationResult.validatedData;
-          validationErrors = validationResult.validationErrors;
-        } else {
-          validatedData = isStream ? [] : data;
+      if (options.allowErrorsRatio !== void 0) {
+        insertOptions.clickhouse_settings.input_format_allow_errors_ratio = options.allowErrorsRatio;
+      }
+    }
+    return insertOptions;
+  }
+  /**
+   * Creates success result for completed insertions
+   * @private
+   */
+  createSuccessResult(data, validatedData, validationErrors, isStream, shouldValidate, strategy) {
+    if (isStream) {
+      return {
+        successful: -1,
+        // -1 indicates stream mode where count is unknown
+        failed: 0,
+        total: -1
+      };
+    }
+    const insertedCount = validatedData.length;
+    const totalProcessed = shouldValidate ? data.length : insertedCount;
+    const result = {
+      successful: insertedCount,
+      failed: shouldValidate ? validationErrors.length : 0,
+      total: totalProcessed
+    };
+    if (shouldValidate && validationErrors.length > 0 && strategy === "discard") {
+      result.failedRecords = validationErrors.map((ve) => ({
+        record: ve.record,
+        error: `Validation error: ${ve.error}`,
+        index: ve.index
+      }));
+    }
+    return result;
+  }
+  /**
+   * Handles insertion errors based on the specified strategy
+   * @private
+   */
+  async handleInsertionError(batchError, strategy, tableName, data, validatedData, validationErrors, isStream, shouldValidate, options) {
+    switch (strategy) {
+      case "fail-fast":
+        throw new Error(
+          `Failed to insert data into table ${tableName}: ${batchError}`
+        );
+      case "discard":
+        throw new Error(
+          `Too many errors during insert into table ${tableName}. Error threshold exceeded: ${batchError}`
+        );
+      case "isolate":
+        return await this.handleIsolateStrategy(
+          batchError,
+          tableName,
+          data,
+          validatedData,
+          validationErrors,
+          isStream,
+          shouldValidate,
+          options
+        );
+      default:
+        throw new Error(`Unknown error strategy: ${strategy}`);
+    }
+  }
+  /**
+   * Handles the isolate strategy for insertion errors
+   * @private
+   */
+  async handleIsolateStrategy(batchError, tableName, data, validatedData, validationErrors, isStream, shouldValidate, options) {
+    if (isStream) {
+      throw new Error(
+        `Isolate strategy is not supported with stream input: ${batchError}`
+      );
+    }
+    try {
+      const { client } = await this.getMemoizedClient();
+      const skipValidationOnRetry = options?.skipValidationOnRetry || false;
+      const retryData = skipValidationOnRetry ? data : validatedData;
+      const { successful, failed } = await this.retryIndividualRecords(
+        client,
+        tableName,
+        retryData
+      );
+      const allFailedRecords = [
+        // Validation errors (if any and not skipping validation on retry)
+        ...shouldValidate && !skipValidationOnRetry ? validationErrors.map((ve) => ({
+          record: ve.record,
+          error: `Validation error: ${ve.error}`,
+          index: ve.index
+        })) : [],
+        // Insertion errors
+        ...failed
+      ];
+      this.checkInsertionThresholds(
+        allFailedRecords,
+        data.length,
+        options
+      );
+      return {
+        successful: successful.length,
+        failed: allFailedRecords.length,
+        total: data.length,
+        failedRecords: allFailedRecords
+      };
+    } catch (isolationError) {
+      throw new Error(
+        `Failed to insert data into table ${tableName} during record isolation: ${isolationError}`
+      );
+    }
+  }
+  /**
+   * Checks if insertion errors exceed configured thresholds
+   * @private
+   */
+  checkInsertionThresholds(failedRecords, totalRecords, options) {
+    const totalFailed = failedRecords.length;
+    const failedRatio = totalFailed / totalRecords;
+    if (options?.allowErrors !== void 0 && totalFailed > options.allowErrors) {
+      throw new Error(
+        `Too many failed records: ${totalFailed} > ${options.allowErrors}. Failed records: ${failedRecords.map((f) => f.error).join(", ")}`
+      );
+    }
+    if (options?.allowErrorsRatio !== void 0 && failedRatio > options.allowErrorsRatio) {
+      throw new Error(
+        `Failed record ratio too high: ${failedRatio.toFixed(3)} > ${options.allowErrorsRatio}. Failed records: ${failedRecords.map((f) => f.error).join(", ")}`
+      );
+    }
+  }
+  /**
+   * Recursively transforms a record to match ClickHouse's JSONEachRow requirements
+   *
+   * - For every Array(Nested(...)) field at any depth, each item is wrapped in its own array and recursively processed.
+   * - For every Nested struct (not array), it recurses into the struct.
+   * - This ensures compatibility with kafka_clickhouse_sync
+   *
+   * @param record The input record to transform (may be deeply nested)
+   * @param columns The schema columns for this level (defaults to this.columnArray at the top level)
+   * @returns The transformed record, ready for ClickHouse JSONEachRow insertion
+   */
+  mapToClickhouseRecord(record, columns = this.columnArray) {
+    const result = { ...record };
+    for (const col of columns) {
+      const value = record[col.name];
+      const dt = col.data_type;
+      if (isArrayNestedType(dt)) {
+        if (Array.isArray(value) && (value.length === 0 || typeof value[0] === "object")) {
+          result[col.name] = value.map((item) => [
+            this.mapToClickhouseRecord(item, dt.elementType.columns)
+          ]);
         }
-        const { client } = await this.getMemoizedClient();
-        const tableName = this.generateTableName();
-        try {
-          const insertOptions = this.prepareInsertOptions(
-            tableName,
-            data,
-            validatedData,
-            isStream,
-            strategy,
-            options
-          );
-          await client.insert(insertOptions);
-          return this.createSuccessResult(
-            data,
-            validatedData,
-            validationErrors,
-            isStream,
-            shouldValidate,
-            strategy
-          );
-        } catch (batchError) {
-          return await this.handleInsertionError(
-            batchError,
-            strategy,
-            tableName,
-            data,
-            validatedData,
-            validationErrors,
-            isStream,
-            shouldValidate,
-            options
-          );
+      } else if (isNestedType(dt)) {
+        if (value && typeof value === "object") {
+          result[col.name] = this.mapToClickhouseRecord(value, dt.columns);
         }
       }
-      // Note: Static factory methods (withS3Queue, withReplacingMergeTree, withMergeTree)
-      // were removed in ENG-856. Use direct configuration instead, e.g.:
-      // new OlapTable(name, { engine: ClickHouseEngines.ReplacingMergeTree, orderByFields: ["id"], ver: "updated_at" })
-    };
+    }
+    return result;
   }
-});
+  /**
+   * Inserts data directly into the ClickHouse table with enhanced error handling and validation.
+   * This method establishes a direct connection to ClickHouse using the project configuration
+   * and inserts the provided data into the versioned table.
+   *
+   * PERFORMANCE OPTIMIZATIONS:
+   * - Memoized client connections with fast config hashing
+   * - Single-pass validation with pre-allocated arrays
+   * - Batch-optimized retry strategy (batches of 10, then individual)
+   * - Optimized ClickHouse settings for large datasets
+   * - Reduced memory allocations and object creation
+   *
+   * Uses advanced typia validation when available for comprehensive type checking,
+   * with fallback to basic validation for compatibility.
+   *
+   * The ClickHouse client is memoized and reused across multiple insert calls for better performance.
+   * If the configuration changes, a new client will be automatically created.
+   *
+   * @param data Array of objects conforming to the table schema, or a Node.js Readable stream
+   * @param options Optional configuration for error handling, validation, and insertion behavior
+   * @returns Promise resolving to detailed insertion results
+   * @throws {ConfigError} When configuration cannot be read or parsed
+   * @throws {ClickHouseError} When insertion fails based on the error strategy
+   * @throws {ValidationError} When validation fails and strategy is 'fail-fast'
+   *
+   * @example
+   * ```typescript
+   * // Create an OlapTable instance (typia validators auto-injected)
+   * const userTable = new OlapTable<User>('users');
+   *
+   * // Insert with comprehensive typia validation
+   * const result1 = await userTable.insert([
+   *   { id: 1, name: 'John', email: 'john@example.com' },
+   *   { id: 2, name: 'Jane', email: 'jane@example.com' }
+   * ]);
+   *
+   * // Insert data with stream input (validation not available for streams)
+   * const dataStream = new Readable({
+   *   objectMode: true,
+   *   read() { // Stream implementation }
+   * });
+   * const result2 = await userTable.insert(dataStream, { strategy: 'fail-fast' });
+   *
+   * // Insert with validation disabled for performance
+   * const result3 = await userTable.insert(data, { validate: false });
+   *
+   * // Insert with error handling strategies
+   * const result4 = await userTable.insert(mixedData, {
+   *   strategy: 'isolate',
+   *   allowErrorsRatio: 0.1,
+   *   validate: true  // Use typia validation (default)
+   * });
+   *
+   * // Optional: Clean up connection when completely done
+   * await userTable.closeClient();
+   * ```
+   */
+  async insert(data, options) {
+    const { isStream, strategy, shouldValidate } = this.validateInsertParameters(data, options);
+    const emptyResult = this.handleEmptyData(data, isStream);
+    if (emptyResult) {
+      return emptyResult;
+    }
+    let validatedData = [];
+    let validationErrors = [];
+    if (!isStream && shouldValidate) {
+      const validationResult = await this.performPreInsertionValidation(
+        data,
+        shouldValidate,
+        strategy,
+        options
+      );
+      validatedData = validationResult.validatedData;
+      validationErrors = validationResult.validationErrors;
+    } else {
+      validatedData = isStream ? [] : data;
+    }
+    const { client } = await this.getMemoizedClient();
+    const tableName = this.generateTableName();
+    try {
+      const insertOptions = this.prepareInsertOptions(
+        tableName,
+        data,
+        validatedData,
+        isStream,
+        strategy,
+        options
+      );
+      await client.insert(insertOptions);
+      return this.createSuccessResult(
+        data,
+        validatedData,
+        validationErrors,
+        isStream,
+        shouldValidate,
+        strategy
+      );
+    } catch (batchError) {
+      return await this.handleInsertionError(
+        batchError,
+        strategy,
+        tableName,
+        data,
+        validatedData,
+        validationErrors,
+        isStream,
+        shouldValidate,
+        options
+      );
+    }
+  }
+  // Note: Static factory methods (withS3Queue, withReplacingMergeTree, withMergeTree)
+  // were removed in ENG-856. Use direct configuration instead, e.g.:
+  // new OlapTable(name, { engine: ClickHouseEngines.ReplacingMergeTree, orderByFields: ["id"], ver: "updated_at" })
+};
 
 // src/dmv2/sdk/stream.ts
 import { createHash as createHash3 } from "crypto";
-function attachTypeGuard(dl, typeGuard) {
-  dl.asTyped = () => typeGuard(dl.originalRecord);
-}
-var RoutedMessage, Stream, DeadLetterQueue;
-var init_stream = __esm({
-  "src/dmv2/sdk/stream.ts"() {
-    "use strict";
-    init_typedBase();
-    init_internal();
-    init_stackTrace();
-    RoutedMessage = class {
-      /** The destination stream for the message */
-      destination;
-      /** The message value(s) to send */
-      values;
-      /**
-       * Creates a new routed message.
-       *
-       * @param destination The target stream
-       * @param values The message(s) to route
-       */
-      constructor(destination, values) {
-        this.destination = destination;
-        this.values = values;
-      }
-    };
-    Stream = class extends TypedBase {
-      defaultDeadLetterQueue;
-      /** @internal Memoized KafkaJS producer for reusing connections across sends */
-      _memoizedProducer;
-      /** @internal Hash of the configuration used to create the memoized Kafka producer */
-      _kafkaConfigHash;
-      constructor(name, config, schema, columns, validators, allowExtraFields) {
-        super(name, config ?? {}, schema, columns, void 0, allowExtraFields);
-        const streams = getMooseInternal().streams;
-        if (streams.has(name)) {
-          throw new Error(`Stream with name ${name} already exists`);
-        }
-        streams.set(name, this);
-        this.defaultDeadLetterQueue = this.config.defaultDeadLetterQueue;
-      }
-      /**
-       * Internal map storing transformation configurations.
-       * Maps destination stream names to arrays of transformation functions and their configs.
-       *
-       * @internal
-       */
-      _transformations = /* @__PURE__ */ new Map();
-      /**
-       * Internal function for multi-stream transformations.
-       * Allows a single transformation to route messages to multiple destinations.
-       *
-       * @internal
-       */
-      _multipleTransformations;
-      /**
-       * Internal array storing consumer configurations.
-       *
-       * @internal
-       */
-      _consumers = new Array();
-      /**
-       * Builds the full Kafka topic name including optional namespace and version suffix.
-       * Version suffix is appended as _x_y_z where dots in version are replaced with underscores.
-       */
-      buildFullTopicName(namespace) {
-        const versionSuffix = this.config.version ? `_${this.config.version.replace(/\./g, "_")}` : "";
-        const base = `${this.name}${versionSuffix}`;
-        return namespace !== void 0 && namespace.length > 0 ? `${namespace}.${base}` : base;
-      }
-      /**
-       * Creates a fast hash string from relevant Kafka configuration fields.
-       */
-      createConfigHash(kafkaConfig) {
-        const configString = [
-          kafkaConfig.broker,
-          kafkaConfig.messageTimeoutMs,
-          kafkaConfig.saslUsername,
-          kafkaConfig.saslPassword,
-          kafkaConfig.saslMechanism,
-          kafkaConfig.securityProtocol,
-          kafkaConfig.namespace
-        ].join(":");
-        return createHash3("sha256").update(configString).digest("hex").substring(0, 16);
-      }
-      /**
-       * Gets or creates a memoized KafkaJS producer using runtime configuration.
-       */
-      async getMemoizedProducer() {
-        await Promise.resolve().then(() => (init_runtime(), runtime_exports));
-        const configRegistry = globalThis._mooseConfigRegistry;
-        const { getKafkaProducer: getKafkaProducer2 } = await Promise.resolve().then(() => (init_commons(), commons_exports));
-        const kafkaConfig = await configRegistry.getKafkaConfig();
-        const currentHash = this.createConfigHash(kafkaConfig);
-        if (this._memoizedProducer && this._kafkaConfigHash === currentHash) {
-          return { producer: this._memoizedProducer, kafkaConfig };
-        }
-        if (this._memoizedProducer && this._kafkaConfigHash !== currentHash) {
-          try {
-            await this._memoizedProducer.disconnect();
-          } catch {
-          }
-          this._memoizedProducer = void 0;
-        }
-        const clientId = `moose-sdk-stream-${this.name}`;
-        const logger = {
-          logPrefix: clientId,
-          log: (message) => {
-            console.log(`${clientId}: ${message}`);
-          },
-          error: (message) => {
-            console.error(`${clientId}: ${message}`);
-          },
-          warn: (message) => {
-            console.warn(`${clientId}: ${message}`);
-          }
-        };
-        const producer = await getKafkaProducer2(
-          {
-            clientId,
-            broker: kafkaConfig.broker,
-            securityProtocol: kafkaConfig.securityProtocol,
-            saslUsername: kafkaConfig.saslUsername,
-            saslPassword: kafkaConfig.saslPassword,
-            saslMechanism: kafkaConfig.saslMechanism
-          },
-          logger
-        );
-        this._memoizedProducer = producer;
-        this._kafkaConfigHash = currentHash;
-        return { producer, kafkaConfig };
-      }
-      /**
-       * Closes the memoized Kafka producer if it exists.
-       */
-      async closeProducer() {
-        if (this._memoizedProducer) {
-          try {
-            await this._memoizedProducer.disconnect();
-          } catch {
-          } finally {
-            this._memoizedProducer = void 0;
-            this._kafkaConfigHash = void 0;
-          }
-        }
+var RoutedMessage = class {
+  /** The destination stream for the message */
+  destination;
+  /** The message value(s) to send */
+  values;
+  /**
+   * Creates a new routed message.
+   *
+   * @param destination The target stream
+   * @param values The message(s) to route
+   */
+  constructor(destination, values) {
+    this.destination = destination;
+    this.values = values;
+  }
+};
+var Stream = class extends TypedBase {
+  defaultDeadLetterQueue;
+  /** @internal Memoized KafkaJS producer for reusing connections across sends */
+  _memoizedProducer;
+  /** @internal Hash of the configuration used to create the memoized Kafka producer */
+  _kafkaConfigHash;
+  constructor(name, config, schema, columns, validators, allowExtraFields) {
+    super(name, config ?? {}, schema, columns, void 0, allowExtraFields);
+    const streams = getMooseInternal().streams;
+    if (streams.has(name)) {
+      throw new Error(`Stream with name ${name} already exists`);
+    }
+    streams.set(name, this);
+    this.defaultDeadLetterQueue = this.config.defaultDeadLetterQueue;
+  }
+  /**
+   * Internal map storing transformation configurations.
+   * Maps destination stream names to arrays of transformation functions and their configs.
+   *
+   * @internal
+   */
+  _transformations = /* @__PURE__ */ new Map();
+  /**
+   * Internal function for multi-stream transformations.
+   * Allows a single transformation to route messages to multiple destinations.
+   *
+   * @internal
+   */
+  _multipleTransformations;
+  /**
+   * Internal array storing consumer configurations.
+   *
+   * @internal
+   */
+  _consumers = new Array();
+  /**
+   * Builds the full Kafka topic name including optional namespace and version suffix.
+   * Version suffix is appended as _x_y_z where dots in version are replaced with underscores.
+   */
+  buildFullTopicName(namespace) {
+    const versionSuffix = this.config.version ? `_${this.config.version.replace(/\./g, "_")}` : "";
+    const base = `${this.name}${versionSuffix}`;
+    return namespace !== void 0 && namespace.length > 0 ? `${namespace}.${base}` : base;
+  }
+  /**
+   * Creates a fast hash string from relevant Kafka configuration fields.
+   */
+  createConfigHash(kafkaConfig) {
+    const configString = [
+      kafkaConfig.broker,
+      kafkaConfig.messageTimeoutMs,
+      kafkaConfig.saslUsername,
+      kafkaConfig.saslPassword,
+      kafkaConfig.saslMechanism,
+      kafkaConfig.securityProtocol,
+      kafkaConfig.namespace
+    ].join(":");
+    return createHash3("sha256").update(configString).digest("hex").substring(0, 16);
+  }
+  /**
+   * Gets or creates a memoized KafkaJS producer using runtime configuration.
+   */
+  async getMemoizedProducer() {
+    await Promise.resolve().then(() => (init_runtime(), runtime_exports));
+    const configRegistry = globalThis._mooseConfigRegistry;
+    const { getKafkaProducer: getKafkaProducer2 } = await Promise.resolve().then(() => (init_commons(), commons_exports));
+    const kafkaConfig = await configRegistry.getKafkaConfig();
+    const currentHash = this.createConfigHash(kafkaConfig);
+    if (this._memoizedProducer && this._kafkaConfigHash === currentHash) {
+      return { producer: this._memoizedProducer, kafkaConfig };
+    }
+    if (this._memoizedProducer && this._kafkaConfigHash !== currentHash) {
+      try {
+        await this._memoizedProducer.disconnect();
+      } catch {
       }
-      /**
-       * Sends one or more records to this stream's Kafka topic.
-       * Values are JSON-serialized as message values.
-       */
-      async send(values) {
-        const flat = Array.isArray(values) ? values : values !== void 0 && values !== null ? [values] : [];
-        if (flat.length === 0) return;
-        const { producer, kafkaConfig } = await this.getMemoizedProducer();
-        const topic = this.buildFullTopicName(kafkaConfig.namespace);
-        const sr = this.config.schemaConfig;
-        if (sr && sr.kind === "JSON") {
-          const schemaRegistryUrl = kafkaConfig.schemaRegistryUrl;
-          if (!schemaRegistryUrl) {
-            throw new Error("Schema Registry URL not configured");
-          }
-          const {
-            default: { SchemaRegistry }
-          } = await import("@kafkajs/confluent-schema-registry");
-          const registry = new SchemaRegistry({ host: schemaRegistryUrl });
-          let schemaId = void 0;
-          if ("id" in sr.reference) {
-            schemaId = sr.reference.id;
-          } else if ("subjectLatest" in sr.reference) {
-            schemaId = await registry.getLatestSchemaId(sr.reference.subjectLatest);
-          } else if ("subject" in sr.reference) {
-            schemaId = await registry.getRegistryId(
-              sr.reference.subject,
-              sr.reference.version
-            );
-          }
-          if (schemaId === void 0) {
-            throw new Error("Malformed schema reference.");
-          }
-          const encoded = await Promise.all(
-            flat.map(
-              (v) => registry.encode(schemaId, v)
-            )
-          );
-          await producer.send({
-            topic,
-            messages: encoded.map((value) => ({ value }))
-          });
-          return;
-        } else if (sr !== void 0) {
-          throw new Error("Currently only JSON Schema is supported.");
-        }
-        await producer.send({
-          topic,
-          messages: flat.map((v) => ({ value: JSON.stringify(v) }))
-        });
+      this._memoizedProducer = void 0;
+    }
+    const clientId = `moose-sdk-stream-${this.name}`;
+    const logger = {
+      logPrefix: clientId,
+      log: (message) => {
+        console.log(`${clientId}: ${message}`);
+      },
+      error: (message) => {
+        console.error(`${clientId}: ${message}`);
+      },
+      warn: (message) => {
+        console.warn(`${clientId}: ${message}`);
       }
-      /**
-       * Adds a transformation step that processes messages from this stream and sends the results to a destination stream.
-       * Multiple transformations to the same destination stream can be added if they have distinct `version` identifiers in their config.
-       *
-       * @template U The data type of the messages in the destination stream.
-       * @param destination The destination stream for the transformed messages.
-       * @param transformation A function that takes a message of type T and returns zero or more messages of type U (or a Promise thereof).
-       *                       Return `null` or `undefined` or an empty array `[]` to filter out a message. Return an array to emit multiple messages.
-       * @param config Optional configuration for this specific transformation step, like a version.
-       */
-      addTransform(destination, transformation, config) {
-        const sourceFile = getSourceFileFromStack(new Error().stack);
-        const transformConfig = {
-          ...config ?? {},
-          sourceFile
-        };
-        if (transformConfig.deadLetterQueue === void 0) {
-          transformConfig.deadLetterQueue = this.defaultDeadLetterQueue;
-        }
-        if (this._transformations.has(destination.name)) {
-          const existingTransforms = this._transformations.get(destination.name);
-          const hasVersion = existingTransforms.some(
-            ([_, __, cfg]) => cfg.version === transformConfig.version
-          );
-          if (!hasVersion) {
-            existingTransforms.push([destination, transformation, transformConfig]);
-          }
-        } else {
-          this._transformations.set(destination.name, [
-            [destination, transformation, transformConfig]
-          ]);
-        }
+    };
+    const producer = await getKafkaProducer2(
+      {
+        clientId,
+        broker: kafkaConfig.broker,
+        securityProtocol: kafkaConfig.securityProtocol,
+        saslUsername: kafkaConfig.saslUsername,
+        saslPassword: kafkaConfig.saslPassword,
+        saslMechanism: kafkaConfig.saslMechanism
+      },
+      logger
+    );
+    this._memoizedProducer = producer;
+    this._kafkaConfigHash = currentHash;
+    return { producer, kafkaConfig };
+  }
+  /**
+   * Closes the memoized Kafka producer if it exists.
+   */
+  async closeProducer() {
+    if (this._memoizedProducer) {
+      try {
+        await this._memoizedProducer.disconnect();
+      } catch {
+      } finally {
+        this._memoizedProducer = void 0;
+        this._kafkaConfigHash = void 0;
       }
-      /**
-       * Adds a consumer function that processes messages from this stream.
-       * Multiple consumers can be added if they have distinct `version` identifiers in their config.
-       *
-       * @param consumer A function that takes a message of type T and performs an action (e.g., side effect, logging). Should return void or Promise<void>.
-       * @param config Optional configuration for this specific consumer, like a version.
-       */
-      addConsumer(consumer, config) {
-        const sourceFile = getSourceFileFromStack(new Error().stack);
-        const consumerConfig = {
-          ...config ?? {},
-          sourceFile
-        };
-        if (consumerConfig.deadLetterQueue === void 0) {
-          consumerConfig.deadLetterQueue = this.defaultDeadLetterQueue;
-        }
-        const hasVersion = this._consumers.some(
-          (existing) => existing.config.version === consumerConfig.version
+    }
+  }
+  /**
+   * Sends one or more records to this stream's Kafka topic.
+   * Values are JSON-serialized as message values.
+   */
+  async send(values) {
+    const flat = Array.isArray(values) ? values : values !== void 0 && values !== null ? [values] : [];
+    if (flat.length === 0) return;
+    const { producer, kafkaConfig } = await this.getMemoizedProducer();
+    const topic = this.buildFullTopicName(kafkaConfig.namespace);
+    const sr = this.config.schemaConfig;
+    if (sr && sr.kind === "JSON") {
+      const schemaRegistryUrl = kafkaConfig.schemaRegistryUrl;
+      if (!schemaRegistryUrl) {
+        throw new Error("Schema Registry URL not configured");
+      }
+      const {
+        default: { SchemaRegistry }
+      } = await import("@kafkajs/confluent-schema-registry");
+      const registry = new SchemaRegistry({ host: schemaRegistryUrl });
+      let schemaId = void 0;
+      if ("id" in sr.reference) {
+        schemaId = sr.reference.id;
+      } else if ("subjectLatest" in sr.reference) {
+        schemaId = await registry.getLatestSchemaId(sr.reference.subjectLatest);
+      } else if ("subject" in sr.reference) {
+        schemaId = await registry.getRegistryId(
+          sr.reference.subject,
+          sr.reference.version
         );
-        if (!hasVersion) {
-          this._consumers.push({ consumer, config: consumerConfig });
-        }
       }
-      /**
-       * Helper method for `addMultiTransform` to specify the destination and values for a routed message.
-       * @param values The value or values to send to this stream.
-       * @returns A `RoutedMessage` object associating the values with this stream.
-       *
-       * @example
-       * ```typescript
-       * sourceStream.addMultiTransform((record) => [
-       *   destinationStream1.routed(transformedRecord1),
-       *   destinationStream2.routed([record2a, record2b])
-       * ]);
-       * ```
-       */
-      routed = (values) => new RoutedMessage(this, values);
-      /**
-       * Adds a single transformation function that can route messages to multiple destination streams.
-       * This is an alternative to adding multiple individual `addTransform` calls.
-       * Only one multi-transform function can be added per stream.
-       *
-       * @param transformation A function that takes a message of type T and returns an array of `RoutedMessage` objects,
-       *                       each specifying a destination stream and the message(s) to send to it.
-       */
-      addMultiTransform(transformation) {
-        this._multipleTransformations = transformation;
+      if (schemaId === void 0) {
+        throw new Error("Malformed schema reference.");
       }
+      const encoded = await Promise.all(
+        flat.map(
+          (v) => registry.encode(schemaId, v)
+        )
+      );
+      await producer.send({
+        topic,
+        messages: encoded.map((value) => ({ value }))
+      });
+      return;
+    } else if (sr !== void 0) {
+      throw new Error("Currently only JSON Schema is supported.");
+    }
+    await producer.send({
+      topic,
+      messages: flat.map((v) => ({ value: JSON.stringify(v) }))
+    });
+  }
+  /**
+   * Adds a transformation step that processes messages from this stream and sends the results to a destination stream.
+   * Multiple transformations to the same destination stream can be added if they have distinct `version` identifiers in their config.
+   *
+   * @template U The data type of the messages in the destination stream.
+   * @param destination The destination stream for the transformed messages.
+   * @param transformation A function that takes a message of type T and returns zero or more messages of type U (or a Promise thereof).
+   *                       Return `null` or `undefined` or an empty array `[]` to filter out a message. Return an array to emit multiple messages.
+   * @param config Optional configuration for this specific transformation step, like a version.
+   */
+  addTransform(destination, transformation, config) {
+    const sourceFile = getSourceFileFromStack(new Error().stack);
+    const transformConfig = {
+      ...config ?? {},
+      sourceFile
     };
-    DeadLetterQueue = class extends Stream {
-      constructor(name, config, typeGuard) {
-        if (typeGuard === void 0) {
-          throw new Error(
-            "Supply the type param T so that the schema is inserted by the compiler plugin."
-          );
-        }
-        super(name, config ?? {}, dlqSchema, dlqColumns, void 0, false);
-        this.typeGuard = typeGuard;
-        getMooseInternal().streams.set(name, this);
-      }
-      /**
-       * Internal type guard function for validating and casting original records.
-       *
-       * @internal
-       */
-      typeGuard;
-      /**
-       * Adds a transformation step for dead letter records.
-       * The transformation function receives a DeadLetter<T> with type recovery capabilities.
-       *
-       * @template U The output type for the transformation
-       * @param destination The destination stream for transformed messages
-       * @param transformation Function to transform dead letter records
-       * @param config Optional transformation configuration
-       */
-      addTransform(destination, transformation, config) {
-        const withValidate = (deadLetter) => {
-          attachTypeGuard(deadLetter, this.typeGuard);
-          return transformation(deadLetter);
-        };
-        super.addTransform(destination, withValidate, config);
-      }
-      /**
-       * Adds a consumer for dead letter records.
-       * The consumer function receives a DeadLetter<T> with type recovery capabilities.
-       *
-       * @param consumer Function to process dead letter records
-       * @param config Optional consumer configuration
-       */
-      addConsumer(consumer, config) {
-        const withValidate = (deadLetter) => {
-          attachTypeGuard(deadLetter, this.typeGuard);
-          return consumer(deadLetter);
-        };
-        super.addConsumer(withValidate, config);
-      }
-      /**
-       * Adds a multi-stream transformation for dead letter records.
-       * The transformation function receives a DeadLetter<T> with type recovery capabilities.
-       *
-       * @param transformation Function to route dead letter records to multiple destinations
-       */
-      addMultiTransform(transformation) {
-        const withValidate = (deadLetter) => {
-          attachTypeGuard(deadLetter, this.typeGuard);
-          return transformation(deadLetter);
-        };
-        super.addMultiTransform(withValidate);
+    if (transformConfig.deadLetterQueue === void 0) {
+      transformConfig.deadLetterQueue = this.defaultDeadLetterQueue;
+    }
+    if (this._transformations.has(destination.name)) {
+      const existingTransforms = this._transformations.get(destination.name);
+      const hasVersion = existingTransforms.some(
+        ([_, __, cfg]) => cfg.version === transformConfig.version
+      );
+      if (!hasVersion) {
+        existingTransforms.push([destination, transformation, transformConfig]);
       }
+    } else {
+      this._transformations.set(destination.name, [
+        [destination, transformation, transformConfig]
+      ]);
+    }
+  }
+  /**
+   * Adds a consumer function that processes messages from this stream.
+   * Multiple consumers can be added if they have distinct `version` identifiers in their config.
+   *
+   * @param consumer A function that takes a message of type T and performs an action (e.g., side effect, logging). Should return void or Promise<void>.
+   * @param config Optional configuration for this specific consumer, like a version.
+   */
+  addConsumer(consumer, config) {
+    const sourceFile = getSourceFileFromStack(new Error().stack);
+    const consumerConfig = {
+      ...config ?? {},
+      sourceFile
     };
+    if (consumerConfig.deadLetterQueue === void 0) {
+      consumerConfig.deadLetterQueue = this.defaultDeadLetterQueue;
+    }
+    const hasVersion = this._consumers.some(
+      (existing) => existing.config.version === consumerConfig.version
+    );
+    if (!hasVersion) {
+      this._consumers.push({ consumer, config: consumerConfig });
+    }
   }
-});
+  /**
+   * Helper method for `addMultiTransform` to specify the destination and values for a routed message.
+   * @param values The value or values to send to this stream.
+   * @returns A `RoutedMessage` object associating the values with this stream.
+   *
+   * @example
+   * ```typescript
+   * sourceStream.addMultiTransform((record) => [
+   *   destinationStream1.routed(transformedRecord1),
+   *   destinationStream2.routed([record2a, record2b])
+   * ]);
+   * ```
+   */
+  routed = (values) => new RoutedMessage(this, values);
+  /**
+   * Adds a single transformation function that can route messages to multiple destination streams.
+   * This is an alternative to adding multiple individual `addTransform` calls.
+   * Only one multi-transform function can be added per stream.
+   *
+   * @param transformation A function that takes a message of type T and returns an array of `RoutedMessage` objects,
+   *                       each specifying a destination stream and the message(s) to send to it.
+   */
+  addMultiTransform(transformation) {
+    this._multipleTransformations = transformation;
+  }
+};
+function attachTypeGuard(dl, typeGuard) {
+  dl.asTyped = () => typeGuard(dl.originalRecord);
+}
+var DeadLetterQueue = class extends Stream {
+  constructor(name, config, typeGuard) {
+    if (typeGuard === void 0) {
+      throw new Error(
+        "Supply the type param T so that the schema is inserted by the compiler plugin."
+      );
+    }
+    super(name, config ?? {}, dlqSchema, dlqColumns, void 0, false);
+    this.typeGuard = typeGuard;
+    getMooseInternal().streams.set(name, this);
+  }
+  /**
+   * Internal type guard function for validating and casting original records.
+   *
+   * @internal
+   */
+  typeGuard;
+  /**
+   * Adds a transformation step for dead letter records.
+   * The transformation function receives a DeadLetter<T> with type recovery capabilities.
+   *
+   * @template U The output type for the transformation
+   * @param destination The destination stream for transformed messages
+   * @param transformation Function to transform dead letter records
+   * @param config Optional transformation configuration
+   */
+  addTransform(destination, transformation, config) {
+    const withValidate = (deadLetter) => {
+      attachTypeGuard(deadLetter, this.typeGuard);
+      return transformation(deadLetter);
+    };
+    super.addTransform(destination, withValidate, config);
+  }
+  /**
+   * Adds a consumer for dead letter records.
+   * The consumer function receives a DeadLetter<T> with type recovery capabilities.
+   *
+   * @param consumer Function to process dead letter records
+   * @param config Optional consumer configuration
+   */
+  addConsumer(consumer, config) {
+    const withValidate = (deadLetter) => {
+      attachTypeGuard(deadLetter, this.typeGuard);
+      return consumer(deadLetter);
+    };
+    super.addConsumer(withValidate, config);
+  }
+  /**
+   * Adds a multi-stream transformation for dead letter records.
+   * The transformation function receives a DeadLetter<T> with type recovery capabilities.
+   *
+   * @param transformation Function to route dead letter records to multiple destinations
+   */
+  addMultiTransform(transformation) {
+    const withValidate = (deadLetter) => {
+      attachTypeGuard(deadLetter, this.typeGuard);
+      return transformation(deadLetter);
+    };
+    super.addMultiTransform(withValidate);
+  }
+};
 
 // src/dmv2/sdk/workflow.ts
-var Task, Workflow;
-var init_workflow = __esm({
-  "src/dmv2/sdk/workflow.ts"() {
-    "use strict";
-    init_internal();
-    Task = class {
-      /**
-       * Creates a new Task instance.
-       *
-       * @param name - Unique identifier for the task
-       * @param config - Configuration object defining the task behavior
-       *
-       * @example
-       * ```typescript
-       * // No input, no output
-       * const task1 = new Task<null, void>("task1", {
-       *   run: async () => {
-       *     console.log("No input/output");
-       *   }
-       * });
-       *
-       * // No input, but has output
-       * const task2 = new Task<null, OutputType>("task2", {
-       *   run: async () => {
-       *     return someOutput;
-       *   }
-       * });
-       *
-       * // Has input, no output
-       * const task3 = new Task<InputType, void>("task3", {
-       *   run: async (input: InputType) => {
-       *     // process input but return nothing
-       *   }
-       * });
-       *
-       * // Has both input and output
-       * const task4 = new Task<InputType, OutputType>("task4", {
-       *   run: async (input: InputType) => {
-       *     return process(input);
-       *   }
-       * });
-       * ```
-       */
-      constructor(name, config) {
-        this.name = name;
-        this.config = config;
+var Task = class {
+  /**
+   * Creates a new Task instance.
+   *
+   * @param name - Unique identifier for the task
+   * @param config - Configuration object defining the task behavior
+   *
+   * @example
+   * ```typescript
+   * // No input, no output
+   * const task1 = new Task<null, void>("task1", {
+   *   run: async () => {
+   *     console.log("No input/output");
+   *   }
+   * });
+   *
+   * // No input, but has output
+   * const task2 = new Task<null, OutputType>("task2", {
+   *   run: async () => {
+   *     return someOutput;
+   *   }
+   * });
+   *
+   * // Has input, no output
+   * const task3 = new Task<InputType, void>("task3", {
+   *   run: async (input: InputType) => {
+   *     // process input but return nothing
+   *   }
+   * });
+   *
+   * // Has both input and output
+   * const task4 = new Task<InputType, OutputType>("task4", {
+   *   run: async (input: InputType) => {
+   *     return process(input);
+   *   }
+   * });
+   * ```
+   */
+  constructor(name, config) {
+    this.name = name;
+    this.config = config;
+  }
+};
+var Workflow = class {
+  /**
+   * Creates a new Workflow instance and registers it with the Moose system.
+   *
+   * @param name - Unique identifier for the workflow
+   * @param config - Configuration object defining the workflow behavior and task orchestration
+   * @throws {Error} When the workflow contains null/undefined tasks or infinite loops
+   */
+  constructor(name, config) {
+    this.name = name;
+    this.config = config;
+    const workflows = getMooseInternal().workflows;
+    if (workflows.has(name)) {
+      throw new Error(`Workflow with name ${name} already exists`);
+    }
+    this.validateTaskGraph(config.startingTask, name);
+    workflows.set(name, this);
+  }
+  /**
+   * Validates the task graph to ensure there are no null tasks or infinite loops.
+   *
+   * @private
+   * @param startingTask - The starting task to begin validation from
+   * @param workflowName - The name of the workflow being validated (for error messages)
+   * @throws {Error} When null/undefined tasks are found or infinite loops are detected
+   */
+  validateTaskGraph(startingTask, workflowName) {
+    if (startingTask === null || startingTask === void 0) {
+      throw new Error(
+        `Workflow "${workflowName}" has a null or undefined starting task`
+      );
+    }
+    const visited = /* @__PURE__ */ new Set();
+    const recursionStack = /* @__PURE__ */ new Set();
+    const validateTask = (task, currentPath) => {
+      if (task === null || task === void 0) {
+        const pathStr = currentPath.length > 0 ? currentPath.join(" -> ") + " -> " : "";
+        throw new Error(
+          `Workflow "${workflowName}" contains a null or undefined task in the task chain: ${pathStr}null`
+        );
       }
-    };
-    Workflow = class {
-      /**
-       * Creates a new Workflow instance and registers it with the Moose system.
-       *
-       * @param name - Unique identifier for the workflow
-       * @param config - Configuration object defining the workflow behavior and task orchestration
-       * @throws {Error} When the workflow contains null/undefined tasks or infinite loops
-       */
-      constructor(name, config) {
-        this.name = name;
-        this.config = config;
-        const workflows = getMooseInternal().workflows;
-        if (workflows.has(name)) {
-          throw new Error(`Workflow with name ${name} already exists`);
-        }
-        this.validateTaskGraph(config.startingTask, name);
-        workflows.set(name, this);
+      const taskName = task.name;
+      if (recursionStack.has(taskName)) {
+        const cycleStartIndex = currentPath.indexOf(taskName);
+        const cyclePath = cycleStartIndex >= 0 ? currentPath.slice(cycleStartIndex).concat(taskName) : currentPath.concat(taskName);
+        throw new Error(
+          `Workflow "${workflowName}" contains an infinite loop in task chain: ${cyclePath.join(" -> ")}`
+        );
       }
-      /**
-       * Validates the task graph to ensure there are no null tasks or infinite loops.
-       *
-       * @private
-       * @param startingTask - The starting task to begin validation from
-       * @param workflowName - The name of the workflow being validated (for error messages)
-       * @throws {Error} When null/undefined tasks are found or infinite loops are detected
-       */
-      validateTaskGraph(startingTask, workflowName) {
-        if (startingTask === null || startingTask === void 0) {
-          throw new Error(
-            `Workflow "${workflowName}" has a null or undefined starting task`
-          );
+      if (visited.has(taskName)) {
+        return;
+      }
+      visited.add(taskName);
+      recursionStack.add(taskName);
+      if (task.config.onComplete) {
+        for (const nextTask of task.config.onComplete) {
+          validateTask(nextTask, [...currentPath, taskName]);
         }
-        const visited = /* @__PURE__ */ new Set();
-        const recursionStack = /* @__PURE__ */ new Set();
-        const validateTask = (task, currentPath) => {
-          if (task === null || task === void 0) {
-            const pathStr = currentPath.length > 0 ? currentPath.join(" -> ") + " -> " : "";
-            throw new Error(
-              `Workflow "${workflowName}" contains a null or undefined task in the task chain: ${pathStr}null`
-            );
-          }
-          const taskName = task.name;
-          if (recursionStack.has(taskName)) {
-            const cycleStartIndex = currentPath.indexOf(taskName);
-            const cyclePath = cycleStartIndex >= 0 ? currentPath.slice(cycleStartIndex).concat(taskName) : currentPath.concat(taskName);
-            throw new Error(
-              `Workflow "${workflowName}" contains an infinite loop in task chain: ${cyclePath.join(" -> ")}`
-            );
-          }
-          if (visited.has(taskName)) {
-            return;
-          }
-          visited.add(taskName);
-          recursionStack.add(taskName);
-          if (task.config.onComplete) {
-            for (const nextTask of task.config.onComplete) {
-              validateTask(nextTask, [...currentPath, taskName]);
-            }
-          }
-          recursionStack.delete(taskName);
-        };
-        validateTask(startingTask, []);
       }
+      recursionStack.delete(taskName);
     };
+    validateTask(startingTask, []);
   }
-});
+};
 
 // src/dmv2/sdk/ingestApi.ts
-var IngestApi;
-var init_ingestApi = __esm({
-  "src/dmv2/sdk/ingestApi.ts"() {
-    "use strict";
-    init_typedBase();
-    init_internal();
-    IngestApi = class extends TypedBase {
-      constructor(name, config, schema, columns, validators, allowExtraFields) {
-        super(name, config, schema, columns, void 0, allowExtraFields);
-        const ingestApis = getMooseInternal().ingestApis;
-        if (ingestApis.has(name)) {
-          throw new Error(`Ingest API with name ${name} already exists`);
-        }
-        ingestApis.set(name, this);
-      }
-    };
+var IngestApi = class extends TypedBase {
+  constructor(name, config, schema, columns, validators, allowExtraFields) {
+    super(name, config, schema, columns, void 0, allowExtraFields);
+    const ingestApis = getMooseInternal().ingestApis;
+    if (ingestApis.has(name)) {
+      throw new Error(`Ingest API with name ${name} already exists`);
+    }
+    ingestApis.set(name, this);
   }
-});
+};
 
 // src/dmv2/sdk/consumptionApi.ts
-var Api, ConsumptionApi;
-var init_consumptionApi = __esm({
-  "src/dmv2/sdk/consumptionApi.ts"() {
-    "use strict";
-    init_typedBase();
-    init_internal();
-    Api = class extends TypedBase {
-      /** @internal The handler function that processes requests and generates responses. */
-      _handler;
-      /** @internal The JSON schema definition for the response type R. */
-      responseSchema;
-      constructor(name, handler, config, schema, columns, responseSchema) {
-        super(name, config ?? {}, schema, columns);
-        this._handler = handler;
-        this.responseSchema = responseSchema ?? {
-          version: "3.1",
-          schemas: [{ type: "array", items: { type: "object" } }],
-          components: { schemas: {} }
-        };
-        const apis = getMooseInternal().apis;
-        const key = `${name}${config?.version ? `:${config.version}` : ""}`;
-        if (apis.has(key)) {
-          throw new Error(
-            `Consumption API with name ${name} and version ${config?.version} already exists`
-          );
-        }
-        apis.set(key, this);
-        if (config?.path) {
-          if (config.version) {
-            const pathEndsWithVersion = config.path.endsWith(`/${config.version}`) || config.path === config.version || config.path.endsWith(config.version) && config.path.length > config.version.length && config.path[config.path.length - config.version.length - 1] === "/";
-            if (pathEndsWithVersion) {
-              if (apis.has(config.path)) {
-                const existing = apis.get(config.path);
-                throw new Error(
-                  `Cannot register API "${name}" with path "${config.path}" - this path is already used by API "${existing.name}"`
-                );
-              }
-              apis.set(config.path, this);
-            } else {
-              const versionedPath = `${config.path.replace(/\/$/, "")}/${config.version}`;
-              if (apis.has(versionedPath)) {
-                const existing = apis.get(versionedPath);
-                throw new Error(
-                  `Cannot register API "${name}" with path "${versionedPath}" - this path is already used by API "${existing.name}"`
-                );
-              }
-              apis.set(versionedPath, this);
-              if (!apis.has(config.path)) {
-                apis.set(config.path, this);
-              }
-            }
-          } else {
-            if (apis.has(config.path)) {
-              const existing = apis.get(config.path);
-              throw new Error(
-                `Cannot register API "${name}" with custom path "${config.path}" - this path is already used by API "${existing.name}"`
-              );
-            }
+var Api = class extends TypedBase {
+  /** @internal The handler function that processes requests and generates responses. */
+  _handler;
+  /** @internal The JSON schema definition for the response type R. */
+  responseSchema;
+  constructor(name, handler, config, schema, columns, responseSchema) {
+    super(name, config ?? {}, schema, columns);
+    this._handler = handler;
+    this.responseSchema = responseSchema ?? {
+      version: "3.1",
+      schemas: [{ type: "array", items: { type: "object" } }],
+      components: { schemas: {} }
+    };
+    const apis = getMooseInternal().apis;
+    const key = `${name}${config?.version ? `:${config.version}` : ""}`;
+    if (apis.has(key)) {
+      throw new Error(
+        `Consumption API with name ${name} and version ${config?.version} already exists`
+      );
+    }
+    apis.set(key, this);
+    if (config?.path) {
+      if (config.version) {
+        const pathEndsWithVersion = config.path.endsWith(`/${config.version}`) || config.path === config.version || config.path.endsWith(config.version) && config.path.length > config.version.length && config.path[config.path.length - config.version.length - 1] === "/";
+        if (pathEndsWithVersion) {
+          if (apis.has(config.path)) {
+            const existing = apis.get(config.path);
+            throw new Error(
+              `Cannot register API "${name}" with path "${config.path}" - this path is already used by API "${existing.name}"`
+            );
+          }
+          apis.set(config.path, this);
+        } else {
+          const versionedPath = `${config.path.replace(/\/$/, "")}/${config.version}`;
+          if (apis.has(versionedPath)) {
+            const existing = apis.get(versionedPath);
+            throw new Error(
+              `Cannot register API "${name}" with path "${versionedPath}" - this path is already used by API "${existing.name}"`
+            );
+          }
+          apis.set(versionedPath, this);
+          if (!apis.has(config.path)) {
             apis.set(config.path, this);
           }
         }
+      } else {
+        if (apis.has(config.path)) {
+          const existing = apis.get(config.path);
+          throw new Error(
+            `Cannot register API "${name}" with custom path "${config.path}" - this path is already used by API "${existing.name}"`
+          );
+        }
+        apis.set(config.path, this);
       }
-      /**
-       * Retrieves the handler function associated with this Consumption API.
-       * @returns The handler function.
-       */
-      getHandler = () => {
-        return this._handler;
-      };
-      async call(baseUrl, queryParams) {
-        let path2;
-        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;
-            } else {
-              path2 = `${this.config.path.replace(/\/$/, "")}/${this.config.version}`;
-            }
-          } else {
-            path2 = this.config.path;
-          }
+    }
+  }
+  /**
+   * Retrieves the handler function associated with this Consumption API.
+   * @returns The handler function.
+   */
+  getHandler = () => {
+    return this._handler;
+  };
+  async call(baseUrl, queryParams) {
+    let path2;
+    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;
         } else {
-          path2 = this.config?.version ? `${this.name}/${this.config.version}` : this.name;
-        }
-        const url = new URL(`${baseUrl.replace(/\/$/, "")}/api/${path2}`);
-        const searchParams = url.searchParams;
-        for (const [key, value] of Object.entries(queryParams)) {
-          if (Array.isArray(value)) {
-            for (const item of value) {
-              if (item !== null && item !== void 0) {
-                searchParams.append(key, String(item));
-              }
-            }
-          } else if (value !== null && value !== void 0) {
-            searchParams.append(key, String(value));
-          }
+          path2 = `${this.config.path.replace(/\/$/, "")}/${this.config.version}`;
         }
-        const response = await fetch(url, {
-          method: "GET",
-          headers: {
-            Accept: "application/json"
+      } else {
+        path2 = this.config.path;
+      }
+    } else {
+      path2 = this.config?.version ? `${this.name}/${this.config.version}` : this.name;
+    }
+    const url = new URL(`${baseUrl.replace(/\/$/, "")}/api/${path2}`);
+    const searchParams = url.searchParams;
+    for (const [key, value] of Object.entries(queryParams)) {
+      if (Array.isArray(value)) {
+        for (const item of value) {
+          if (item !== null && item !== void 0) {
+            searchParams.append(key, String(item));
           }
-        });
-        if (!response.ok) {
-          throw new Error(`HTTP error! status: ${response.status}`);
         }
-        const data = await response.json();
-        return data;
+      } else if (value !== null && value !== void 0) {
+        searchParams.append(key, String(value));
       }
-    };
-    ConsumptionApi = Api;
+    }
+    const response = await fetch(url, {
+      method: "GET",
+      headers: {
+        Accept: "application/json"
+      }
+    });
+    if (!response.ok) {
+      throw new Error(`HTTP error! status: ${response.status}`);
+    }
+    const data = await response.json();
+    return data;
   }
-});
+};
+var ConsumptionApi = Api;
 
 // src/dmv2/sdk/ingestPipeline.ts
-var IngestPipeline;
-var init_ingestPipeline = __esm({
-  "src/dmv2/sdk/ingestPipeline.ts"() {
-    "use strict";
-    init_typedBase();
-    init_stream();
-    init_olapTable();
-    init_ingestApi();
-    init_helpers();
-    IngestPipeline = class extends TypedBase {
-      /**
-       * The OLAP table component of the pipeline, if configured.
-       * Provides analytical query capabilities for the ingested data.
-       * Only present when `config.table` is not `false`.
-       */
-      table;
-      /**
-       * The stream component of the pipeline, if configured.
-       * Handles real-time data flow and processing between components.
-       * Only present when `config.stream` is not `false`.
-       */
-      stream;
-      /**
-       * The ingest API component of the pipeline, if configured.
-       * Provides HTTP endpoints for data ingestion.
-       * Only present when `config.ingestApi` is not `false`.
-       */
-      ingestApi;
-      /** The dead letter queue of the pipeline, if configured. */
-      deadLetterQueue;
-      constructor(name, config, schema, columns, validators, allowExtraFields) {
-        super(name, config, schema, columns, validators, allowExtraFields);
-        if (config.ingest !== void 0) {
-          console.warn(
-            "\u26A0\uFE0F  DEPRECATION WARNING: The 'ingest' parameter is deprecated and will be removed in a future version. Please use 'ingestApi' instead."
-          );
-          if (config.ingestApi === void 0) {
-            config.ingestApi = config.ingest;
-          }
-        }
-        if (config.table) {
-          const tableConfig = typeof config.table === "object" ? {
-            ...config.table,
-            lifeCycle: config.table.lifeCycle ?? config.lifeCycle,
-            ...config.version && { version: config.version }
-          } : {
-            lifeCycle: config.lifeCycle,
-            engine: "MergeTree" /* MergeTree */,
-            ...config.version && { version: config.version }
-          };
-          this.table = new OlapTable(
-            name,
-            tableConfig,
-            this.schema,
-            this.columnArray,
-            this.validators
-          );
-        }
-        if (config.deadLetterQueue) {
-          const streamConfig = {
-            destination: void 0,
-            ...typeof config.deadLetterQueue === "object" ? {
-              ...config.deadLetterQueue,
-              lifeCycle: config.deadLetterQueue.lifeCycle ?? config.lifeCycle
-            } : { lifeCycle: config.lifeCycle },
-            ...config.version && { version: config.version }
-          };
-          this.deadLetterQueue = new DeadLetterQueue(
-            `${name}DeadLetterQueue`,
-            streamConfig,
-            validators.assert
-          );
-        }
-        if (config.stream) {
-          const streamConfig = {
-            destination: this.table,
-            defaultDeadLetterQueue: this.deadLetterQueue,
-            ...typeof config.stream === "object" ? {
-              ...config.stream,
-              lifeCycle: config.stream.lifeCycle ?? config.lifeCycle
-            } : { lifeCycle: config.lifeCycle },
-            ...config.version && { version: config.version }
-          };
-          this.stream = new Stream(
-            name,
-            streamConfig,
-            this.schema,
-            this.columnArray,
-            void 0,
-            this.allowExtraFields
-          );
-          this.stream.pipelineParent = this;
-        }
-        const effectiveIngestAPI = config.ingestApi !== void 0 ? config.ingestApi : config.ingest;
-        if (effectiveIngestAPI) {
-          if (!this.stream) {
-            throw new Error("Ingest API needs a stream to write to.");
-          }
-          const ingestConfig = {
-            destination: this.stream,
-            deadLetterQueue: this.deadLetterQueue,
-            ...typeof effectiveIngestAPI === "object" ? effectiveIngestAPI : {},
-            ...config.version && { version: config.version },
-            ...config.path && { path: config.path }
-          };
-          this.ingestApi = new IngestApi(
-            name,
-            ingestConfig,
-            this.schema,
-            this.columnArray,
-            void 0,
-            this.allowExtraFields
-          );
-          this.ingestApi.pipelineParent = this;
-        }
+var IngestPipeline = class extends TypedBase {
+  /**
+   * The OLAP table component of the pipeline, if configured.
+   * Provides analytical query capabilities for the ingested data.
+   * Only present when `config.table` is not `false`.
+   */
+  table;
+  /**
+   * The stream component of the pipeline, if configured.
+   * Handles real-time data flow and processing between components.
+   * Only present when `config.stream` is not `false`.
+   */
+  stream;
+  /**
+   * The ingest API component of the pipeline, if configured.
+   * Provides HTTP endpoints for data ingestion.
+   * Only present when `config.ingestApi` is not `false`.
+   */
+  ingestApi;
+  /** The dead letter queue of the pipeline, if configured. */
+  deadLetterQueue;
+  constructor(name, config, schema, columns, validators, allowExtraFields) {
+    super(name, config, schema, columns, validators, allowExtraFields);
+    if (config.ingest !== void 0) {
+      console.warn(
+        "\u26A0\uFE0F  DEPRECATION WARNING: The 'ingest' parameter is deprecated and will be removed in a future version. Please use 'ingestApi' instead."
+      );
+      if (config.ingestApi === void 0) {
+        config.ingestApi = config.ingest;
       }
-    };
+    }
+    if (config.table) {
+      const tableConfig = typeof config.table === "object" ? {
+        ...config.table,
+        lifeCycle: config.table.lifeCycle ?? config.lifeCycle,
+        ...config.version && { version: config.version }
+      } : {
+        lifeCycle: config.lifeCycle,
+        engine: "MergeTree" /* MergeTree */,
+        ...config.version && { version: config.version }
+      };
+      this.table = new OlapTable(
+        name,
+        tableConfig,
+        this.schema,
+        this.columnArray,
+        this.validators
+      );
+    }
+    if (config.deadLetterQueue) {
+      const streamConfig = {
+        destination: void 0,
+        ...typeof config.deadLetterQueue === "object" ? {
+          ...config.deadLetterQueue,
+          lifeCycle: config.deadLetterQueue.lifeCycle ?? config.lifeCycle
+        } : { lifeCycle: config.lifeCycle },
+        ...config.version && { version: config.version }
+      };
+      this.deadLetterQueue = new DeadLetterQueue(
+        `${name}DeadLetterQueue`,
+        streamConfig,
+        validators.assert
+      );
+    }
+    if (config.stream) {
+      const streamConfig = {
+        destination: this.table,
+        defaultDeadLetterQueue: this.deadLetterQueue,
+        ...typeof config.stream === "object" ? {
+          ...config.stream,
+          lifeCycle: config.stream.lifeCycle ?? config.lifeCycle
+        } : { lifeCycle: config.lifeCycle },
+        ...config.version && { version: config.version }
+      };
+      this.stream = new Stream(
+        name,
+        streamConfig,
+        this.schema,
+        this.columnArray,
+        void 0,
+        this.allowExtraFields
+      );
+      this.stream.pipelineParent = this;
+    }
+    const effectiveIngestAPI = config.ingestApi !== void 0 ? config.ingestApi : config.ingest;
+    if (effectiveIngestAPI) {
+      if (!this.stream) {
+        throw new Error("Ingest API needs a stream to write to.");
+      }
+      const ingestConfig = {
+        destination: this.stream,
+        deadLetterQueue: this.deadLetterQueue,
+        ...typeof effectiveIngestAPI === "object" ? effectiveIngestAPI : {},
+        ...config.version && { version: config.version },
+        ...config.path && { path: config.path }
+      };
+      this.ingestApi = new IngestApi(
+        name,
+        ingestConfig,
+        this.schema,
+        this.columnArray,
+        void 0,
+        this.allowExtraFields
+      );
+      this.ingestApi.pipelineParent = this;
+    }
   }
-});
+};
 
 // src/dmv2/sdk/etlPipeline.ts
-var InternalBatcher, ETLPipeline;
-var init_etlPipeline = __esm({
-  "src/dmv2/sdk/etlPipeline.ts"() {
-    "use strict";
-    init_workflow();
-    InternalBatcher = class {
-      iterator;
-      batchSize;
-      constructor(asyncIterable, batchSize = 20) {
-        this.iterator = asyncIterable[Symbol.asyncIterator]();
-        this.batchSize = batchSize;
-      }
-      async getNextBatch() {
-        const items = [];
-        for (let i = 0; i < this.batchSize; i++) {
-          const { value, done } = await this.iterator.next();
-          if (done) {
-            return { items, hasMore: false };
-          }
-          items.push(value);
-        }
-        return { items, hasMore: true };
-      }
+var InternalBatcher = class {
+  iterator;
+  batchSize;
+  constructor(asyncIterable, batchSize = 20) {
+    this.iterator = asyncIterable[Symbol.asyncIterator]();
+    this.batchSize = batchSize;
+  }
+  async getNextBatch() {
+    const items = [];
+    for (let i = 0; i < this.batchSize; i++) {
+      const { value, done } = await this.iterator.next();
+      if (done) {
+        return { items, hasMore: false };
+      }
+      items.push(value);
+    }
+    return { items, hasMore: true };
+  }
+};
+var ETLPipeline = class {
+  constructor(name, config) {
+    this.name = name;
+    this.config = config;
+    this.setupPipeline();
+  }
+  batcher;
+  setupPipeline() {
+    this.batcher = this.createBatcher();
+    const tasks = this.createAllTasks();
+    tasks.extract.config.onComplete = [tasks.transform];
+    tasks.transform.config.onComplete = [tasks.load];
+    new Workflow(this.name, {
+      startingTask: tasks.extract,
+      retries: 1,
+      timeout: "30m"
+    });
+  }
+  createBatcher() {
+    const iterable = typeof this.config.extract === "function" ? this.config.extract() : this.config.extract;
+    return new InternalBatcher(iterable);
+  }
+  getDefaultTaskConfig() {
+    return {
+      retries: 1,
+      timeout: "30m"
     };
-    ETLPipeline = class {
-      constructor(name, config) {
-        this.name = name;
-        this.config = config;
-        this.setupPipeline();
-      }
-      batcher;
-      setupPipeline() {
-        this.batcher = this.createBatcher();
-        const tasks = this.createAllTasks();
-        tasks.extract.config.onComplete = [tasks.transform];
-        tasks.transform.config.onComplete = [tasks.load];
-        new Workflow(this.name, {
-          startingTask: tasks.extract,
-          retries: 1,
-          timeout: "30m"
-        });
-      }
-      createBatcher() {
-        const iterable = typeof this.config.extract === "function" ? this.config.extract() : this.config.extract;
-        return new InternalBatcher(iterable);
-      }
-      getDefaultTaskConfig() {
-        return {
-          retries: 1,
-          timeout: "30m"
-        };
-      }
-      createAllTasks() {
-        const taskConfig = this.getDefaultTaskConfig();
-        return {
-          extract: this.createExtractTask(taskConfig),
-          transform: this.createTransformTask(taskConfig),
-          load: this.createLoadTask(taskConfig)
-        };
-      }
-      createExtractTask(taskConfig) {
-        return new Task(`${this.name}_extract`, {
-          run: async ({}) => {
-            console.log(`Running extract task for ${this.name}...`);
-            const batch = await this.batcher.getNextBatch();
-            console.log(`Extract task completed with ${batch.items.length} items`);
-            return batch;
-          },
-          retries: taskConfig.retries,
-          timeout: taskConfig.timeout
-        });
-      }
-      createTransformTask(taskConfig) {
-        return new Task(
-          `${this.name}_transform`,
-          {
-            // Use new single-parameter context API for handlers
-            run: async ({ input }) => {
-              const batch = input;
-              console.log(
-                `Running transform task for ${this.name} with ${batch.items.length} items...`
-              );
-              const transformedItems = [];
-              for (const item of batch.items) {
-                const transformed = await this.config.transform(item);
-                transformedItems.push(transformed);
-              }
-              console.log(
-                `Transform task completed with ${transformedItems.length} items`
-              );
-              return { items: transformedItems };
-            },
-            retries: taskConfig.retries,
-            timeout: taskConfig.timeout
-          }
-        );
-      }
-      createLoadTask(taskConfig) {
-        return new Task(`${this.name}_load`, {
-          run: async ({ input: transformedItems }) => {
-            console.log(
-              `Running load task for ${this.name} with ${transformedItems.items.length} items...`
-            );
-            if ("insert" in this.config.load) {
-              await this.config.load.insert(transformedItems.items);
-            } else {
-              await this.config.load(transformedItems.items);
-            }
-            console.log(`Load task completed`);
-          },
-          retries: taskConfig.retries,
-          timeout: taskConfig.timeout
-        });
-      }
-      // Execute the entire ETL pipeline
-      async run() {
-        console.log(`Starting ETL Pipeline: ${this.name}`);
-        let batchNumber = 1;
-        do {
-          console.log(`Processing batch ${batchNumber}...`);
-          const batch = await this.batcher.getNextBatch();
-          if (batch.items.length === 0) {
-            break;
-          }
+  }
+  createAllTasks() {
+    const taskConfig = this.getDefaultTaskConfig();
+    return {
+      extract: this.createExtractTask(taskConfig),
+      transform: this.createTransformTask(taskConfig),
+      load: this.createLoadTask(taskConfig)
+    };
+  }
+  createExtractTask(taskConfig) {
+    return new Task(`${this.name}_extract`, {
+      run: async ({}) => {
+        console.log(`Running extract task for ${this.name}...`);
+        const batch = await this.batcher.getNextBatch();
+        console.log(`Extract task completed with ${batch.items.length} items`);
+        return batch;
+      },
+      retries: taskConfig.retries,
+      timeout: taskConfig.timeout
+    });
+  }
+  createTransformTask(taskConfig) {
+    return new Task(
+      `${this.name}_transform`,
+      {
+        // Use new single-parameter context API for handlers
+        run: async ({ input }) => {
+          const batch = input;
+          console.log(
+            `Running transform task for ${this.name} with ${batch.items.length} items...`
+          );
           const transformedItems = [];
-          for (const extractedData of batch.items) {
-            const transformedData = await this.config.transform(extractedData);
-            transformedItems.push(transformedData);
-          }
-          if ("insert" in this.config.load) {
-            await this.config.load.insert(transformedItems);
-          } else {
-            await this.config.load(transformedItems);
+          for (const item of batch.items) {
+            const transformed = await this.config.transform(item);
+            transformedItems.push(transformed);
           }
           console.log(
-            `Completed batch ${batchNumber} with ${batch.items.length} items`
+            `Transform task completed with ${transformedItems.length} items`
           );
-          batchNumber++;
-          if (!batch.hasMore) {
-            break;
-          }
-        } while (true);
-        console.log(`Completed ETL Pipeline: ${this.name}`);
+          return { items: transformedItems };
+        },
+        retries: taskConfig.retries,
+        timeout: taskConfig.timeout
       }
-    };
+    );
   }
-});
-
-// src/dmv2/sdk/sqlResource.ts
-var SqlResource;
-var init_sqlResource = __esm({
-  "src/dmv2/sdk/sqlResource.ts"() {
-    "use strict";
-    init_internal();
-    init_sqlHelpers();
-    init_stackTrace();
-    SqlResource = class {
-      /** @internal */
-      kind = "SqlResource";
-      /** Array of SQL statements to execute for setting up the resource. */
-      setup;
-      /** Array of SQL statements to execute for tearing down the resource. */
-      teardown;
-      /** The name of the SQL resource (e.g., view name, materialized view name). */
-      name;
-      /** List of OlapTables or Views that this resource reads data from. */
-      pullsDataFrom;
-      /** List of OlapTables or Views that this resource writes data to. */
-      pushesDataTo;
-      /** @internal Source file path where this resource was defined */
-      sourceFile;
-      /** @internal Source line number where this resource was defined */
-      sourceLine;
-      /** @internal Source column number where this resource was defined */
-      sourceColumn;
-      /**
-       * Creates a new SqlResource instance.
-       * @param name The name of the resource.
-       * @param setup An array of SQL DDL statements to create the resource.
-       * @param teardown An array of SQL DDL statements to drop the resource.
-       * @param options Optional configuration for specifying data dependencies.
-       * @param options.pullsDataFrom Tables/Views this resource reads from.
-       * @param options.pushesDataTo Tables/Views this resource writes to.
-       */
-      constructor(name, setup, teardown, options) {
-        const sqlResources = getMooseInternal().sqlResources;
-        if (!isClientOnlyMode() && sqlResources.has(name)) {
-          throw new Error(`SqlResource with name ${name} already exists`);
-        }
-        sqlResources.set(name, this);
-        this.name = name;
-        this.setup = setup.map(
-          (sql3) => typeof sql3 === "string" ? sql3 : toStaticQuery(sql3)
+  createLoadTask(taskConfig) {
+    return new Task(`${this.name}_load`, {
+      run: async ({ input: transformedItems }) => {
+        console.log(
+          `Running load task for ${this.name} with ${transformedItems.items.length} items...`
         );
-        this.teardown = teardown.map(
-          (sql3) => typeof sql3 === "string" ? sql3 : toStaticQuery(sql3)
-        );
-        this.pullsDataFrom = options?.pullsDataFrom ?? [];
-        this.pushesDataTo = options?.pushesDataTo ?? [];
-        const stack = new Error().stack;
-        const location = getSourceLocationFromStack(stack);
-        if (location) {
-          this.sourceFile = location.file;
-          this.sourceLine = location.line;
-          this.sourceColumn = location.column;
+        if ("insert" in this.config.load) {
+          await this.config.load.insert(transformedItems.items);
+        } else {
+          await this.config.load(transformedItems.items);
         }
+        console.log(`Load task completed`);
+      },
+      retries: taskConfig.retries,
+      timeout: taskConfig.timeout
+    });
+  }
+  // Execute the entire ETL pipeline
+  async run() {
+    console.log(`Starting ETL Pipeline: ${this.name}`);
+    let batchNumber = 1;
+    do {
+      console.log(`Processing batch ${batchNumber}...`);
+      const batch = await this.batcher.getNextBatch();
+      if (batch.items.length === 0) {
+        break;
+      }
+      const transformedItems = [];
+      for (const extractedData of batch.items) {
+        const transformedData = await this.config.transform(extractedData);
+        transformedItems.push(transformedData);
+      }
+      if ("insert" in this.config.load) {
+        await this.config.load.insert(transformedItems);
+      } else {
+        await this.config.load(transformedItems);
       }
-    };
+      console.log(
+        `Completed batch ${batchNumber} with ${batch.items.length} items`
+      );
+      batchNumber++;
+      if (!batch.hasMore) {
+        break;
+      }
+    } while (true);
+    console.log(`Completed ETL Pipeline: ${this.name}`);
   }
-});
+};
+
+// src/dmv2/sdk/sqlResource.ts
+var SqlResource = class {
+  /** @internal */
+  kind = "SqlResource";
+  /** Array of SQL statements to execute for setting up the resource. */
+  setup;
+  /** Array of SQL statements to execute for tearing down the resource. */
+  teardown;
+  /** The name of the SQL resource (e.g., view name, materialized view name). */
+  name;
+  /** List of OlapTables or Views that this resource reads data from. */
+  pullsDataFrom;
+  /** List of OlapTables or Views that this resource writes data to. */
+  pushesDataTo;
+  /** @internal Source file path where this resource was defined */
+  sourceFile;
+  /** @internal Source line number where this resource was defined */
+  sourceLine;
+  /** @internal Source column number where this resource was defined */
+  sourceColumn;
+  /**
+   * Creates a new SqlResource instance.
+   * @param name The name of the resource.
+   * @param setup An array of SQL DDL statements to create the resource.
+   * @param teardown An array of SQL DDL statements to drop the resource.
+   * @param options Optional configuration for specifying data dependencies.
+   * @param options.pullsDataFrom Tables/Views this resource reads from.
+   * @param options.pushesDataTo Tables/Views this resource writes to.
+   */
+  constructor(name, setup, teardown, options) {
+    const sqlResources = getMooseInternal().sqlResources;
+    if (!isClientOnlyMode() && sqlResources.has(name)) {
+      throw new Error(`SqlResource with name ${name} already exists`);
+    }
+    sqlResources.set(name, this);
+    this.name = name;
+    this.setup = setup.map(
+      (sql3) => typeof sql3 === "string" ? sql3 : toStaticQuery(sql3)
+    );
+    this.teardown = teardown.map(
+      (sql3) => typeof sql3 === "string" ? sql3 : toStaticQuery(sql3)
+    );
+    this.pullsDataFrom = options?.pullsDataFrom ?? [];
+    this.pushesDataTo = options?.pushesDataTo ?? [];
+    const stack = new Error().stack;
+    const location = getSourceLocationFromStack(stack);
+    if (location) {
+      this.sourceFile = location.file;
+      this.sourceLine = location.line;
+      this.sourceColumn = location.column;
+    }
+  }
+};
 
 // src/dmv2/sdk/materializedView.ts
-var requireTargetTableName, MaterializedView;
-var init_materializedView = __esm({
-  "src/dmv2/sdk/materializedView.ts"() {
-    "use strict";
-    init_helpers();
-    init_sqlHelpers();
-    init_olapTable();
-    init_sqlResource();
-    requireTargetTableName = (tableName) => {
-      if (typeof tableName === "string") {
-        return tableName;
-      } else {
-        throw new Error("Name of targetTable is not specified.");
-      }
-    };
-    MaterializedView = class extends SqlResource {
-      /** The target OlapTable instance where the materialized data is stored. */
-      targetTable;
-      constructor(options, targetSchema, targetColumns) {
-        let selectStatement = options.selectStatement;
-        if (typeof selectStatement !== "string") {
-          selectStatement = toStaticQuery(selectStatement);
-        }
-        if (targetSchema === void 0 || targetColumns === void 0) {
-          throw new Error(
-            "Supply the type param T so that the schema is inserted by the compiler plugin."
-          );
-        }
-        const targetTable = options.targetTable instanceof OlapTable ? options.targetTable : new OlapTable(
-          requireTargetTableName(
-            options.targetTable?.name ?? options.tableName
-          ),
-          {
-            orderByFields: options.targetTable?.orderByFields ?? options.orderByFields,
-            engine: options.targetTable?.engine ?? options.engine ?? "MergeTree" /* MergeTree */
-          },
-          targetSchema,
-          targetColumns
-        );
-        if (targetTable.name === options.materializedViewName) {
-          throw new Error(
-            "Materialized view name cannot be the same as the target table name."
-          );
-        }
-        super(
-          options.materializedViewName,
-          [
-            createMaterializedView({
-              name: options.materializedViewName,
-              destinationTable: targetTable.name,
-              select: selectStatement
-            })
-            // Population is now handled automatically by Rust infrastructure
-            // based on table engine type and whether this is a new or updated view
-          ],
-          [dropView(options.materializedViewName)],
-          {
-            pullsDataFrom: options.selectTables,
-            pushesDataTo: [targetTable]
-          }
-        );
-        this.targetTable = targetTable;
+var requireTargetTableName = (tableName) => {
+  if (typeof tableName === "string") {
+    return tableName;
+  } else {
+    throw new Error("Name of targetTable is not specified.");
+  }
+};
+var MaterializedView = class extends SqlResource {
+  /** The target OlapTable instance where the materialized data is stored. */
+  targetTable;
+  constructor(options, targetSchema, targetColumns) {
+    let selectStatement = options.selectStatement;
+    if (typeof selectStatement !== "string") {
+      selectStatement = toStaticQuery(selectStatement);
+    }
+    if (targetSchema === void 0 || targetColumns === void 0) {
+      throw new Error(
+        "Supply the type param T so that the schema is inserted by the compiler plugin."
+      );
+    }
+    const targetTable = options.targetTable instanceof OlapTable ? options.targetTable : new OlapTable(
+      requireTargetTableName(
+        options.targetTable?.name ?? options.tableName
+      ),
+      {
+        orderByFields: options.targetTable?.orderByFields ?? options.orderByFields,
+        engine: options.targetTable?.engine ?? options.engine ?? "MergeTree" /* MergeTree */
+      },
+      targetSchema,
+      targetColumns
+    );
+    if (targetTable.name === options.materializedViewName) {
+      throw new Error(
+        "Materialized view name cannot be the same as the target table name."
+      );
+    }
+    super(
+      options.materializedViewName,
+      [
+        createMaterializedView({
+          name: options.materializedViewName,
+          destinationTable: targetTable.name,
+          select: selectStatement
+        })
+        // Population is now handled automatically by Rust infrastructure
+        // based on table engine type and whether this is a new or updated view
+      ],
+      [dropView(options.materializedViewName)],
+      {
+        pullsDataFrom: options.selectTables,
+        pushesDataTo: [targetTable]
       }
-    };
+    );
+    this.targetTable = targetTable;
   }
-});
+};
 
 // src/dmv2/sdk/view.ts
-var View;
-var init_view = __esm({
-  "src/dmv2/sdk/view.ts"() {
-    "use strict";
-    init_helpers();
-    init_sqlHelpers();
-    init_sqlResource();
-    View = class extends SqlResource {
-      /**
-       * Creates a new View instance.
-       * @param name The name of the view to be created.
-       * @param selectStatement The SQL SELECT statement that defines the view's logic.
-       * @param baseTables An array of OlapTable or View objects that the `selectStatement` reads from. Used for dependency tracking.
-       */
-      constructor(name, selectStatement, baseTables) {
-        if (typeof selectStatement !== "string") {
-          selectStatement = toStaticQuery(selectStatement);
-        }
-        super(
-          name,
-          [
-            `CREATE VIEW IF NOT EXISTS ${name} 
+var View = class extends SqlResource {
+  /**
+   * Creates a new View instance.
+   * @param name The name of the view to be created.
+   * @param selectStatement The SQL SELECT statement that defines the view's logic.
+   * @param baseTables An array of OlapTable or View objects that the `selectStatement` reads from. Used for dependency tracking.
+   */
+  constructor(name, selectStatement, baseTables) {
+    if (typeof selectStatement !== "string") {
+      selectStatement = toStaticQuery(selectStatement);
+    }
+    super(
+      name,
+      [
+        `CREATE VIEW IF NOT EXISTS ${name} 
           AS ${selectStatement}`.trim()
-          ],
-          [dropView(name)],
-          {
-            pullsDataFrom: baseTables
-          }
-        );
+      ],
+      [dropView(name)],
+      {
+        pullsDataFrom: baseTables
       }
-    };
+    );
   }
-});
+};
 
 // src/dmv2/sdk/lifeCycle.ts
-var LifeCycle;
-var init_lifeCycle = __esm({
-  "src/dmv2/sdk/lifeCycle.ts"() {
-    "use strict";
-    LifeCycle = /* @__PURE__ */ ((LifeCycle2) => {
-      LifeCycle2["FULLY_MANAGED"] = "FULLY_MANAGED";
-      LifeCycle2["DELETION_PROTECTED"] = "DELETION_PROTECTED";
-      LifeCycle2["EXTERNALLY_MANAGED"] = "EXTERNALLY_MANAGED";
-      return LifeCycle2;
-    })(LifeCycle || {});
-  }
-});
+var LifeCycle = /* @__PURE__ */ ((LifeCycle2) => {
+  LifeCycle2["FULLY_MANAGED"] = "FULLY_MANAGED";
+  LifeCycle2["DELETION_PROTECTED"] = "DELETION_PROTECTED";
+  LifeCycle2["EXTERNALLY_MANAGED"] = "EXTERNALLY_MANAGED";
+  return LifeCycle2;
+})(LifeCycle || {});
 
 // src/dmv2/sdk/webApp.ts
-var RESERVED_MOUNT_PATHS, WebApp;
-var init_webApp = __esm({
-  "src/dmv2/sdk/webApp.ts"() {
-    "use strict";
-    init_internal();
-    RESERVED_MOUNT_PATHS = [
-      "/admin",
-      "/api",
-      "/consumption",
-      "/health",
-      "/ingest",
-      "/moose",
-      // reserved for future use
-      "/ready",
-      "/workflows"
-    ];
-    WebApp = class {
-      name;
-      handler;
-      config;
-      _rawApp;
-      constructor(name, appOrHandler, config) {
-        this.name = name;
-        this.config = config;
-        if (!this.config.mountPath) {
-          throw new Error(
-            `mountPath is required. Please specify a mount path for your WebApp (e.g., "/myapi").`
-          );
-        }
-        const mountPath = this.config.mountPath;
-        if (mountPath === "/") {
-          throw new Error(
-            `mountPath cannot be "/" as it would allow routes to overlap with reserved paths: ${RESERVED_MOUNT_PATHS.join(", ")}`
-          );
-        }
-        if (mountPath.endsWith("/")) {
+var RESERVED_MOUNT_PATHS = [
+  "/admin",
+  "/api",
+  "/consumption",
+  "/health",
+  "/ingest",
+  "/moose",
+  // reserved for future use
+  "/ready",
+  "/workflows"
+];
+var WebApp = class {
+  name;
+  handler;
+  config;
+  _rawApp;
+  constructor(name, appOrHandler, config) {
+    this.name = name;
+    this.config = config;
+    if (!this.config.mountPath) {
+      throw new Error(
+        `mountPath is required. Please specify a mount path for your WebApp (e.g., "/myapi").`
+      );
+    }
+    const mountPath = this.config.mountPath;
+    if (mountPath === "/") {
+      throw new Error(
+        `mountPath cannot be "/" as it would allow routes to overlap with reserved paths: ${RESERVED_MOUNT_PATHS.join(", ")}`
+      );
+    }
+    if (mountPath.endsWith("/")) {
+      throw new Error(
+        `mountPath cannot end with a trailing slash. Remove the '/' from: "${mountPath}"`
+      );
+    }
+    for (const reserved of RESERVED_MOUNT_PATHS) {
+      if (mountPath === reserved || mountPath.startsWith(`${reserved}/`)) {
+        throw new Error(
+          `mountPath cannot begin with a reserved path: ${RESERVED_MOUNT_PATHS.join(", ")}. Got: "${mountPath}"`
+        );
+      }
+    }
+    this.handler = this.toHandler(appOrHandler);
+    this._rawApp = typeof appOrHandler === "function" ? void 0 : appOrHandler;
+    const webApps = getMooseInternal().webApps;
+    if (webApps.has(name)) {
+      throw new Error(`WebApp with name ${name} already exists`);
+    }
+    if (this.config.mountPath) {
+      for (const [existingName, existingApp] of webApps) {
+        if (existingApp.config.mountPath === this.config.mountPath) {
           throw new Error(
-            `mountPath cannot end with a trailing slash. Remove the '/' from: "${mountPath}"`
+            `WebApp with mountPath "${this.config.mountPath}" already exists (used by WebApp "${existingName}")`
           );
         }
-        for (const reserved of RESERVED_MOUNT_PATHS) {
-          if (mountPath === reserved || mountPath.startsWith(`${reserved}/`)) {
-            throw new Error(
-              `mountPath cannot begin with a reserved path: ${RESERVED_MOUNT_PATHS.join(", ")}. Got: "${mountPath}"`
-            );
-          }
-        }
-        this.handler = this.toHandler(appOrHandler);
-        this._rawApp = typeof appOrHandler === "function" ? void 0 : appOrHandler;
-        const webApps = getMooseInternal().webApps;
-        if (webApps.has(name)) {
-          throw new Error(`WebApp with name ${name} already exists`);
-        }
-        if (this.config.mountPath) {
-          for (const [existingName, existingApp] of webApps) {
-            if (existingApp.config.mountPath === this.config.mountPath) {
-              throw new Error(
-                `WebApp with mountPath "${this.config.mountPath}" already exists (used by WebApp "${existingName}")`
-              );
-            }
-          }
-        }
-        webApps.set(name, this);
       }
-      toHandler(appOrHandler) {
-        if (typeof appOrHandler === "function") {
-          return appOrHandler;
-        }
-        const app = appOrHandler;
-        if (typeof app.handle === "function") {
-          return (req, res) => {
-            app.handle(req, res, (err) => {
-              if (err) {
-                console.error("WebApp handler error:", err);
-                if (!res.headersSent) {
-                  res.writeHead(500, { "Content-Type": "application/json" });
-                  res.end(JSON.stringify({ error: "Internal Server Error" }));
-                }
-              }
-            });
-          };
-        }
-        if (typeof app.callback === "function") {
-          return app.callback();
-        }
-        if (typeof app.routing === "function") {
-          const routing = app.routing;
-          const appWithReady = app;
-          let readyPromise = null;
-          return async (req, res) => {
-            if (readyPromise === null) {
-              readyPromise = typeof appWithReady.ready === "function" ? appWithReady.ready() : Promise.resolve();
+    }
+    webApps.set(name, this);
+  }
+  toHandler(appOrHandler) {
+    if (typeof appOrHandler === "function") {
+      return appOrHandler;
+    }
+    const app = appOrHandler;
+    if (typeof app.handle === "function") {
+      return (req, res) => {
+        app.handle(req, res, (err) => {
+          if (err) {
+            console.error("WebApp handler error:", err);
+            if (!res.headersSent) {
+              res.writeHead(500, { "Content-Type": "application/json" });
+              res.end(JSON.stringify({ error: "Internal Server Error" }));
             }
-            await readyPromise;
-            routing(req, res);
-          };
-        }
-        throw new Error(
-          `Unable to convert app to handler. The provided object must be:
+          }
+        });
+      };
+    }
+    if (typeof app.callback === "function") {
+      return app.callback();
+    }
+    if (typeof app.routing === "function") {
+      const routing = app.routing;
+      const appWithReady = app;
+      let readyPromise = null;
+      return async (req, res) => {
+        if (readyPromise === null) {
+          readyPromise = typeof appWithReady.ready === "function" ? appWithReady.ready() : Promise.resolve();
+        }
+        await readyPromise;
+        routing(req, res);
+      };
+    }
+    throw new Error(
+      `Unable to convert app to handler. The provided object must be:
       - A function (raw Node.js handler)
       - An object with .handle() method (Express, Connect)
       - An object with .callback() method (Koa)
@@ -2746,14 +2493,12 @@ Examples:
   Fastify: new WebApp("name", fastifyApp)
   Raw:     new WebApp("name", (req, res) => { ... })
       `
-        );
-      }
-      getRawApp() {
-        return this._rawApp;
-      }
-    };
+    );
   }
-});
+  getRawApp() {
+    return this._rawApp;
+  }
+};
 
 // src/dmv2/registry.ts
 function getTables() {
@@ -2819,32 +2564,6 @@ function getWebApps() {
 function getWebApp(name) {
   return getMooseInternal().webApps.get(name);
 }
-var init_registry = __esm({
-  "src/dmv2/registry.ts"() {
-    "use strict";
-    init_internal();
-  }
-});
-
-// src/dmv2/index.ts
-var init_dmv2 = __esm({
-  "src/dmv2/index.ts"() {
-    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();
-  }
-});
-init_dmv2();
 export {
   Api,
   ConsumptionApi,