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

package/dist/dmv2/index.mjs

@@ -8,6 +8,247 @@ 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, {
@@ -175,6 +416,298 @@ 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";
@@ -359,2129 +892,1849 @@ var init_runtime = __esm({
   }
 });
 
-// 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 };
-      }
-    }
-  }
-};
-
-// 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: {}
-      }
-    }
-  },
-  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) {
+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);
       }
-    }
-    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;
+      /**
+       * 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;
       }
-    }
-  }
-  /**
-   * 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)]
-        };
+      /**
+       * 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);
       }
-    }
-    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 {
+      /**
+       * 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 };
+      }
+      /**
+       * 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;
+          }
+        }
+      }
+      /**
+       * 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");
+      }
+      /**
+       * 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: result.errors?.join(", ") || "Validation failed",
+                  index: i,
+                  path: "root"
+                });
+              }
+            }
+          } catch (error) {
             invalid.push({
               record,
-              error: result.errors?.join(", ") || "Validation failed",
+              error: error instanceof Error ? error.message : String(error),
               index: i,
               path: "root"
             });
           }
         }
-      } catch (error) {
-        invalid.push({
-          record,
-          error: error instanceof Error ? error.message : String(error),
-          index: i,
-          path: "root"
-        });
+        return {
+          valid,
+          invalid,
+          total: dataLength
+        };
       }
-    }
-    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];
+      /**
+       * 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: [record],
+              values: batch,
               format: "JSONEachRow",
               clickhouse_settings: {
-                date_time_input_format: "best_effort"
+                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(record);
-          } catch (error) {
-            failed.push({
-              record,
-              error: error instanceof Error ? error.message : String(error),
-              index: i + j
-            });
+            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 };
       }
-    }
-    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);
+      /**
+       * 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":
-            return { validatedData, validationErrors };
+            this.checkValidationThresholds(validationErrors, data.length, options);
+            break;
           case "isolate":
-            return { validatedData: data, validationErrors };
-          default:
-            return { validatedData, validationErrors };
+            break;
         }
       }
-      return { validatedData, validationErrors };
-    } catch (validationError) {
-      if (strategy === "fail-fast") {
-        throw validationError;
+      /**
+       * 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(", ")}`
+          );
+        }
       }
-      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
+      /**
+       * 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;
+          }
+        }
+        return insertOptions;
       }
-    };
-    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;
+      /**
+       * 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;
       }
-      if (options.allowErrorsRatio !== void 0) {
-        insertOptions.clickhouse_settings.input_format_allow_errors_ratio = options.allowErrorsRatio;
+      /**
+       * 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}`);
+        }
       }
-    }
-    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)
-          ]);
+      /**
+       * 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}`
+          );
         }
-      } else if (isNestedType(dt)) {
-        if (value && typeof value === "object") {
-          result[col.name] = this.mapToClickhouseRecord(value, dt.columns);
+        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 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
-      );
-    }
+      /**
+       * 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)
+              ]);
+            }
+          } else if (isNestedType(dt)) {
+            if (value && typeof value === "object") {
+              result[col.name] = this.mapToClickhouseRecord(value, dt.columns);
+            }
+          }
+        }
+        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" })
+    };
   }
-  // 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";
-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 {
-      }
-      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}`);
+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;
       }
     };
-    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;
+    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;
       }
-    }
-  }
-  /**
-   * 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
+      /**
+       * 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 };
       }
-      if (schemaId === void 0) {
-        throw new Error("Malformed schema reference.");
+      /**
+       * 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;
+          }
+        }
       }
-      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
-    };
-    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]);
+      /**
+       * 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) }))
+        });
       }
-    } 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 = 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`
-        );
+      /**
+       * 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 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(" -> ")}`
+      /**
+       * 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 });
+        }
       }
-      if (visited.has(taskName)) {
-        return;
+      /**
+       * 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;
       }
-      visited.add(taskName);
-      recursionStack.add(taskName);
-      if (task.config.onComplete) {
-        for (const nextTask of task.config.onComplete) {
-          validateTask(nextTask, [...currentPath, taskName]);
+    };
+    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);
       }
-      recursionStack.delete(taskName);
     };
-    validateTask(startingTask, []);
   }
-};
-
-// src/dmv2/sdk/ingestApi.ts
-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 = 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: {} }
+// 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;
+      }
     };
-    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);
+    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(
-              `Cannot register API "${name}" with path "${config.path}" - this path is already used by API "${existing.name}"`
+              `Workflow "${workflowName}" contains a null or undefined task in the task chain: ${pathStr}null`
             );
           }
-          apis.set(config.path, this);
-        } else {
-          const versionedPath = `${config.path.replace(/\/$/, "")}/${config.version}`;
-          if (apis.has(versionedPath)) {
-            const existing = apis.get(versionedPath);
+          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(
-              `Cannot register API "${name}" with path "${versionedPath}" - this path is already used by API "${existing.name}"`
+              `Workflow "${workflowName}" contains an infinite loop in task chain: ${cyclePath.join(" -> ")}`
             );
           }
-          apis.set(versionedPath, this);
-          if (!apis.has(config.path)) {
-            apis.set(config.path, this);
+          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, []);
+      }
+    };
+  }
+});
+
+// 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`);
         }
-      } else {
-        if (apis.has(config.path)) {
-          const existing = apis.get(config.path);
+        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(
-            `Cannot register API "${name}" with custom path "${config.path}" - this path is already used by API "${existing.name}"`
+            `Consumption API with name ${name} and version ${config?.version} already exists`
           );
         }
-        apis.set(config.path, this);
+        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;
+      /**
+       * 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;
+          }
         } else {
-          path2 = `${this.config.path.replace(/\/$/, "")}/${this.config.version}`;
+          path2 = this.config?.version ? `${this.name}/${this.config.version}` : this.name;
         }
-      } 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));
+        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));
+          }
+        }
+        const response = await fetch(url, {
+          method: "GET",
+          headers: {
+            Accept: "application/json"
           }
+        });
+        if (!response.ok) {
+          throw new Error(`HTTP error! status: ${response.status}`);
         }
-      } else if (value !== null && value !== void 0) {
-        searchParams.append(key, String(value));
+        const data = await response.json();
+        return data;
       }
-    }
-    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;
+    };
+    ConsumptionApi = Api;
   }
-};
-var ConsumptionApi = Api;
+});
 
 // src/dmv2/sdk/ingestPipeline.ts
-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;
+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;
+        }
       }
-    }
-    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 = 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"
-    };
-  }
-  createAllTasks() {
-    const taskConfig = this.getDefaultTaskConfig();
-    return {
-      extract: this.createExtractTask(taskConfig),
-      transform: this.createTransformTask(taskConfig),
-      load: this.createLoadTask(taskConfig)
+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 };
+      }
     };
-  }
-  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...`
-          );
+    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;
+          }
           const transformedItems = [];
-          for (const item of batch.items) {
-            const transformed = await this.config.transform(item);
-            transformedItems.push(transformed);
+          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(
-            `Transform task completed with ${transformedItems.length} items`
+            `Completed batch ${batchNumber} with ${batch.items.length} items`
           );
-          return { items: transformedItems };
-        },
-        retries: taskConfig.retries,
-        timeout: taskConfig.timeout
+          batchNumber++;
+          if (!batch.hasMore) {
+            break;
+          }
+        } while (true);
+        console.log(`Completed ETL Pipeline: ${this.name}`);
       }
-    );
+    };
   }
-  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...`
+});
+
+// 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)
         );
-        if ("insert" in this.config.load) {
-          await this.config.load.insert(transformedItems.items);
-        } else {
-          await this.config.load(transformedItems.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;
         }
-        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 = (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]
+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.");
       }
-    );
-    this.targetTable = targetTable;
+    };
+    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 = 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;
+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} 
           AS ${selectStatement}`.trim()
-      ],
-      [dropView(name)],
-      {
-        pullsDataFrom: baseTables
+          ],
+          [dropView(name)],
+          {
+            pullsDataFrom: baseTables
+          }
+        );
       }
-    );
+    };
   }
-};
+});
 
 // src/dmv2/sdk/lifeCycle.ts
-var LifeCycle = /* @__PURE__ */ ((LifeCycle2) => {
-  LifeCycle2["FULLY_MANAGED"] = "FULLY_MANAGED";
-  LifeCycle2["DELETION_PROTECTED"] = "DELETION_PROTECTED";
-  LifeCycle2["EXTERNALLY_MANAGED"] = "EXTERNALLY_MANAGED";
-  return LifeCycle2;
-})(LifeCycle || {});
+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 || {});
+  }
+});
 
 // src/dmv2/sdk/webApp.ts
-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) {
+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(
-            `WebApp with mountPath "${this.config.mountPath}" already exists (used by WebApp "${existingName}")`
+            `mountPath is required. Please specify a mount path for your WebApp (e.g., "/myapi").`
           );
         }
-      }
-    }
-    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" }));
+        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(
+                `WebApp with mountPath "${this.config.mountPath}" already exists (used by WebApp "${existingName}")`
+              );
             }
           }
-        });
-      };
-    }
-    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:
+        }
+        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();
+            }
+            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)
@@ -2493,12 +2746,14 @@ 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() {
@@ -2564,6 +2819,32 @@ 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,