@invect/core 0.0.1

package/dist/services/flow-versions/flow-versions.service.cjs

@@ -0,0 +1,72 @@
+const require_errors_types = require("../../types/common/errors.types.cjs");
+//#region src/services/flow-versions/flow-versions.service.ts
+var FlowVersionsService = class {
+	constructor(logger, databaseService) {
+		this.logger = logger;
+		this.databaseService = databaseService;
+		if (!databaseService) throw new Error("DatabaseService is required for FlowVersionsService operation. Please update your code to pass a DatabaseService instance.");
+	}
+	/**
+	* Create flow version
+	*/
+	async createFlowVersion(flowId, createVersionRequest) {
+		this.logger.info("Creating flow version", { flowId });
+		try {
+			return await this.databaseService.flowVersions.create(flowId, createVersionRequest);
+		} catch (error) {
+			if (error instanceof require_errors_types.FlowNotFoundError || error instanceof require_errors_types.ValidationError) throw error;
+			this.logger.error("Failed to create flow version", {
+				flowId,
+				error
+			});
+			throw new require_errors_types.DatabaseError("Failed to create flow version", { error });
+		}
+	}
+	/**
+	* Get flow versions
+	*/
+	async listFlowVersionsByFlowId(flowId, options) {
+		this.logger.debug("Retrieving flow versions", { flowId });
+		try {
+			return await this.databaseService.flowVersions.listByFlowId(flowId, options);
+		} catch (error) {
+			if (error instanceof require_errors_types.FlowNotFoundError) throw error;
+			this.logger.error("Failed to retrieve flow versions", {
+				flowId,
+				error
+			});
+			throw new require_errors_types.DatabaseError("Failed to retrieve flow versions", { error });
+		}
+	}
+	/**
+	* Get specific flow version by version number or 'latest'
+	*/
+	async getFlowVersion(flowId, version) {
+		this.logger.debug("Retrieving flow version", {
+			flowId,
+			version
+		});
+		try {
+			let versionParam;
+			if (version === "latest") versionParam = "latest";
+			else {
+				const numVersion = typeof version === "string" ? parseFloat(version) : version;
+				if (isNaN(numVersion)) throw new require_errors_types.ValidationError(`Invalid version format: ${version}`);
+				versionParam = numVersion;
+			}
+			return await this.databaseService.flowVersions.findByKey(flowId, versionParam);
+		} catch (error) {
+			if (error instanceof require_errors_types.FlowNotFoundError || error instanceof require_errors_types.ValidationError) throw error;
+			this.logger.error("Failed to retrieve flow version", {
+				flowId,
+				version,
+				error
+			});
+			throw new require_errors_types.DatabaseError("Failed to retrieve flow version", { error });
+		}
+	}
+};
+//#endregion
+exports.FlowVersionsService = FlowVersionsService;
+
+//# sourceMappingURL=flow-versions.service.cjs.map

package/dist/services/flow-versions/flow-versions.service.cjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"flow-versions.service.cjs","names":["FlowNotFoundError","ValidationError","DatabaseError"],"sources":["../../../src/services/flow-versions/flow-versions.service.ts"],"sourcesContent":["import { ValidationError, FlowNotFoundError, DatabaseError } from 'src/types/common/errors.types';\nimport { CreateFlowVersionRequest } from './schemas-fresh';\nimport { DatabaseService } from '../database/database.service';\nimport { Logger, PaginatedResponse, QueryOptions } from 'src/types/schemas';\nimport { FlowVersion } from 'src/database';\n\nexport class FlowVersionsService {\n  constructor(\n    private readonly logger: Logger,\n    private readonly databaseService: DatabaseService,\n  ) {\n    if (!databaseService) {\n      throw new Error(\n        'DatabaseService is required for FlowVersionsService operation. Please update your code to pass a DatabaseService instance.',\n      );\n    }\n  }\n\n  /**\n   * Create flow version\n   */\n  async createFlowVersion(flowId: string, createVersionRequest: CreateFlowVersionRequest) {\n    this.logger.info('Creating flow version', { flowId });\n\n    try {\n      return await this.databaseService.flowVersions.create(flowId, createVersionRequest);\n    } catch (error) {\n      if (error instanceof FlowNotFoundError || error instanceof ValidationError) {\n        throw error;\n      }\n      this.logger.error('Failed to create flow version', { flowId, error });\n      throw new DatabaseError('Failed to create flow version', { error });\n    }\n  }\n\n  /**\n   * Get flow versions\n   */\n  async listFlowVersionsByFlowId(\n    flowId: string,\n    options?: QueryOptions<FlowVersion>,\n  ): Promise<PaginatedResponse<FlowVersion>> {\n    this.logger.debug('Retrieving flow versions', { flowId });\n\n    try {\n      return await this.databaseService.flowVersions.listByFlowId(flowId, options);\n    } catch (error) {\n      if (error instanceof FlowNotFoundError) {\n        throw error;\n      }\n      this.logger.error('Failed to retrieve flow versions', { flowId, error });\n      throw new DatabaseError('Failed to retrieve flow versions', { error });\n    }\n  }\n\n  /**\n   * Get specific flow version by version number or 'latest'\n   */\n  async getFlowVersion(\n    flowId: string,\n    version: string | number | 'latest',\n  ): Promise<FlowVersion | null> {\n    this.logger.debug('Retrieving flow version', { flowId, version });\n\n    try {\n      // Convert string numbers to numbers for the database call\n      let versionParam: number | 'latest';\n      if (version === 'latest') {\n        versionParam = 'latest';\n      } else {\n        const numVersion = typeof version === 'string' ? parseFloat(version) : version;\n        if (isNaN(numVersion)) {\n          throw new ValidationError(`Invalid version format: ${version}`);\n        }\n        versionParam = numVersion;\n      }\n\n      return await this.databaseService.flowVersions.findByKey(flowId, versionParam);\n    } catch (error) {\n      if (error instanceof FlowNotFoundError || error instanceof ValidationError) {\n        throw error;\n      }\n      this.logger.error('Failed to retrieve flow version', { flowId, version, error });\n      throw new DatabaseError('Failed to retrieve flow version', { error });\n    }\n  }\n}\n"],"mappings":";;AAMA,IAAa,sBAAb,MAAiC;CAC/B,YACE,QACA,iBACA;AAFiB,OAAA,SAAA;AACA,OAAA,kBAAA;AAEjB,MAAI,CAAC,gBACH,OAAM,IAAI,MACR,6HACD;;;;;CAOL,MAAM,kBAAkB,QAAgB,sBAAgD;AACtF,OAAK,OAAO,KAAK,yBAAyB,EAAE,QAAQ,CAAC;AAErD,MAAI;AACF,UAAO,MAAM,KAAK,gBAAgB,aAAa,OAAO,QAAQ,qBAAqB;WAC5E,OAAO;AACd,OAAI,iBAAiBA,qBAAAA,qBAAqB,iBAAiBC,qBAAAA,gBACzD,OAAM;AAER,QAAK,OAAO,MAAM,iCAAiC;IAAE;IAAQ;IAAO,CAAC;AACrE,SAAM,IAAIC,qBAAAA,cAAc,iCAAiC,EAAE,OAAO,CAAC;;;;;;CAOvE,MAAM,yBACJ,QACA,SACyC;AACzC,OAAK,OAAO,MAAM,4BAA4B,EAAE,QAAQ,CAAC;AAEzD,MAAI;AACF,UAAO,MAAM,KAAK,gBAAgB,aAAa,aAAa,QAAQ,QAAQ;WACrE,OAAO;AACd,OAAI,iBAAiBF,qBAAAA,kBACnB,OAAM;AAER,QAAK,OAAO,MAAM,oCAAoC;IAAE;IAAQ;IAAO,CAAC;AACxE,SAAM,IAAIE,qBAAAA,cAAc,oCAAoC,EAAE,OAAO,CAAC;;;;;;CAO1E,MAAM,eACJ,QACA,SAC6B;AAC7B,OAAK,OAAO,MAAM,2BAA2B;GAAE;GAAQ;GAAS,CAAC;AAEjE,MAAI;GAEF,IAAI;AACJ,OAAI,YAAY,SACd,gBAAe;QACV;IACL,MAAM,aAAa,OAAO,YAAY,WAAW,WAAW,QAAQ,GAAG;AACvE,QAAI,MAAM,WAAW,CACnB,OAAM,IAAID,qBAAAA,gBAAgB,2BAA2B,UAAU;AAEjE,mBAAe;;AAGjB,UAAO,MAAM,KAAK,gBAAgB,aAAa,UAAU,QAAQ,aAAa;WACvE,OAAO;AACd,OAAI,iBAAiBD,qBAAAA,qBAAqB,iBAAiBC,qBAAAA,gBACzD,OAAM;AAER,QAAK,OAAO,MAAM,mCAAmC;IAAE;IAAQ;IAAS;IAAO,CAAC;AAChF,SAAM,IAAIC,qBAAAA,cAAc,mCAAmC,EAAE,OAAO,CAAC"}

package/dist/services/flow-versions/flow-versions.service.d.cts

@@ -0,0 +1,63 @@
+import { PaginatedResponse, QueryOptions } from "../../types/schemas/pagination-sort-filter.cjs";
+import { Logger } from "../../types/schemas-fresh/invect-config.cjs";
+import { CreateFlowVersionRequest } from "./schemas-fresh.cjs";
+import { DatabaseService } from "../database/database.service.cjs";
+import { FlowVersion } from "../../database/schema-sqlite.cjs";
+//#region src/services/flow-versions/flow-versions.service.d.ts
+declare class FlowVersionsService {
+  private readonly logger;
+  private readonly databaseService;
+  constructor(logger: Logger, databaseService: DatabaseService);
+  /**
+   * Create flow version
+   */
+  createFlowVersion(flowId: string, createVersionRequest: CreateFlowVersionRequest): Promise<{
+    createdAt: string;
+    flowId: string;
+    version: number;
+    invectDefinition: {
+      nodes: {
+        id: string;
+        type: string;
+        params: Record<string, unknown>;
+        position?: {
+          x: number;
+          y: number;
+        } | undefined;
+        label?: string | undefined;
+        referenceId?: string | undefined;
+        _loop?: unknown;
+        mapper?: {
+          enabled: boolean;
+          expression: string;
+          mode: "auto" | "iterate" | "reshape";
+          outputMode: "object" | "array" | "concat" | "first" | "last";
+          concurrency: number;
+          onEmpty: "error" | "skip";
+          keyField?: string | undefined;
+        } | undefined;
+      }[];
+      edges: {
+        id: string;
+        source: string;
+        target: string;
+        sourceHandle?: string | undefined;
+        targetHandle?: string | undefined;
+        metadata?: Record<string, unknown> | undefined;
+      }[];
+      metadata?: Record<string, unknown> | undefined;
+    };
+    createdBy: string | null;
+  }>;
+  /**
+   * Get flow versions
+   */
+  listFlowVersionsByFlowId(flowId: string, options?: QueryOptions<FlowVersion>): Promise<PaginatedResponse<FlowVersion>>;
+  /**
+   * Get specific flow version by version number or 'latest'
+   */
+  getFlowVersion(flowId: string, version: string | number | 'latest'): Promise<FlowVersion | null>;
+}
+//#endregion
+export { FlowVersionsService };
+//# sourceMappingURL=flow-versions.service.d.cts.map

package/dist/services/flow-versions/flow-versions.service.d.cts.map

@@ -0,0 +1 @@
+{"version":3,"file":"flow-versions.service.d.cts","names":[],"sources":["../../../src/services/flow-versions/flow-versions.service.ts"],"mappings":";;;;;;cAMa,mBAAA;EAAA,iBAEQ,MAAA;EAAA,iBACA,eAAA;cADA,MAAA,EAAQ,MAAA,EACR,eAAA,EAAiB,eAAA;EAHzB;;;EAeL,iBAAA,CAAkB,MAAA,UAAgB,oBAAA,EAAsB,wBAAA,GAAwB,OAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAiBhF,wBAAA,CACJ,MAAA,UACA,OAAA,GAAU,YAAA,CAAa,WAAA,IACtB,OAAA,CAAQ,iBAAA,CAAkB,WAAA;;;;EAiBvB,cAAA,CACJ,MAAA,UACA,OAAA,+BACC,OAAA,CAAQ,WAAA;AAAA"}

package/dist/services/flow-versions/flow-versions.service.d.ts

@@ -0,0 +1,63 @@
+import { PaginatedResponse, QueryOptions } from "../../types/schemas/pagination-sort-filter.js";
+import { Logger } from "../../types/schemas-fresh/invect-config.js";
+import { CreateFlowVersionRequest } from "./schemas-fresh.js";
+import { DatabaseService } from "../database/database.service.js";
+import { FlowVersion } from "../../database/schema-sqlite.js";
+//#region src/services/flow-versions/flow-versions.service.d.ts
+declare class FlowVersionsService {
+  private readonly logger;
+  private readonly databaseService;
+  constructor(logger: Logger, databaseService: DatabaseService);
+  /**
+   * Create flow version
+   */
+  createFlowVersion(flowId: string, createVersionRequest: CreateFlowVersionRequest): Promise<{
+    createdAt: string;
+    flowId: string;
+    version: number;
+    invectDefinition: {
+      nodes: {
+        id: string;
+        type: string;
+        params: Record<string, unknown>;
+        position?: {
+          x: number;
+          y: number;
+        } | undefined;
+        label?: string | undefined;
+        referenceId?: string | undefined;
+        _loop?: unknown;
+        mapper?: {
+          enabled: boolean;
+          expression: string;
+          mode: "auto" | "iterate" | "reshape";
+          outputMode: "object" | "array" | "concat" | "first" | "last";
+          concurrency: number;
+          onEmpty: "error" | "skip";
+          keyField?: string | undefined;
+        } | undefined;
+      }[];
+      edges: {
+        id: string;
+        source: string;
+        target: string;
+        sourceHandle?: string | undefined;
+        targetHandle?: string | undefined;
+        metadata?: Record<string, unknown> | undefined;
+      }[];
+      metadata?: Record<string, unknown> | undefined;
+    };
+    createdBy: string | null;
+  }>;
+  /**
+   * Get flow versions
+   */
+  listFlowVersionsByFlowId(flowId: string, options?: QueryOptions<FlowVersion>): Promise<PaginatedResponse<FlowVersion>>;
+  /**
+   * Get specific flow version by version number or 'latest'
+   */
+  getFlowVersion(flowId: string, version: string | number | 'latest'): Promise<FlowVersion | null>;
+}
+//#endregion
+export { FlowVersionsService };
+//# sourceMappingURL=flow-versions.service.d.ts.map

package/dist/services/flow-versions/flow-versions.service.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"flow-versions.service.d.ts","names":[],"sources":["../../../src/services/flow-versions/flow-versions.service.ts"],"mappings":";;;;;;cAMa,mBAAA;EAAA,iBAEQ,MAAA;EAAA,iBACA,eAAA;cADA,MAAA,EAAQ,MAAA,EACR,eAAA,EAAiB,eAAA;;AAHtC;;EAeQ,iBAAA,CAAkB,MAAA,UAAgB,oBAAA,EAAsB,wBAAA,GAAwB,OAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAiBhF,wBAAA,CACJ,MAAA,UACA,OAAA,GAAU,YAAA,CAAa,WAAA,IACtB,OAAA,CAAQ,iBAAA,CAAkB,WAAA;;;;EAiBvB,cAAA,CACJ,MAAA,UACA,OAAA,+BACC,OAAA,CAAQ,WAAA;AAAA"}

package/dist/services/flow-versions/flow-versions.service.js

@@ -0,0 +1,72 @@
+import { DatabaseError, FlowNotFoundError, ValidationError } from "../../types/common/errors.types.js";
+//#region src/services/flow-versions/flow-versions.service.ts
+var FlowVersionsService = class {
+	constructor(logger, databaseService) {
+		this.logger = logger;
+		this.databaseService = databaseService;
+		if (!databaseService) throw new Error("DatabaseService is required for FlowVersionsService operation. Please update your code to pass a DatabaseService instance.");
+	}
+	/**
+	* Create flow version
+	*/
+	async createFlowVersion(flowId, createVersionRequest) {
+		this.logger.info("Creating flow version", { flowId });
+		try {
+			return await this.databaseService.flowVersions.create(flowId, createVersionRequest);
+		} catch (error) {
+			if (error instanceof FlowNotFoundError || error instanceof ValidationError) throw error;
+			this.logger.error("Failed to create flow version", {
+				flowId,
+				error
+			});
+			throw new DatabaseError("Failed to create flow version", { error });
+		}
+	}
+	/**
+	* Get flow versions
+	*/
+	async listFlowVersionsByFlowId(flowId, options) {
+		this.logger.debug("Retrieving flow versions", { flowId });
+		try {
+			return await this.databaseService.flowVersions.listByFlowId(flowId, options);
+		} catch (error) {
+			if (error instanceof FlowNotFoundError) throw error;
+			this.logger.error("Failed to retrieve flow versions", {
+				flowId,
+				error
+			});
+			throw new DatabaseError("Failed to retrieve flow versions", { error });
+		}
+	}
+	/**
+	* Get specific flow version by version number or 'latest'
+	*/
+	async getFlowVersion(flowId, version) {
+		this.logger.debug("Retrieving flow version", {
+			flowId,
+			version
+		});
+		try {
+			let versionParam;
+			if (version === "latest") versionParam = "latest";
+			else {
+				const numVersion = typeof version === "string" ? parseFloat(version) : version;
+				if (isNaN(numVersion)) throw new ValidationError(`Invalid version format: ${version}`);
+				versionParam = numVersion;
+			}
+			return await this.databaseService.flowVersions.findByKey(flowId, versionParam);
+		} catch (error) {
+			if (error instanceof FlowNotFoundError || error instanceof ValidationError) throw error;
+			this.logger.error("Failed to retrieve flow version", {
+				flowId,
+				version,
+				error
+			});
+			throw new DatabaseError("Failed to retrieve flow version", { error });
+		}
+	}
+};
+//#endregion
+export { FlowVersionsService };
+
+//# sourceMappingURL=flow-versions.service.js.map

package/dist/services/flow-versions/flow-versions.service.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"flow-versions.service.js","names":[],"sources":["../../../src/services/flow-versions/flow-versions.service.ts"],"sourcesContent":["import { ValidationError, FlowNotFoundError, DatabaseError } from 'src/types/common/errors.types';\nimport { CreateFlowVersionRequest } from './schemas-fresh';\nimport { DatabaseService } from '../database/database.service';\nimport { Logger, PaginatedResponse, QueryOptions } from 'src/types/schemas';\nimport { FlowVersion } from 'src/database';\n\nexport class FlowVersionsService {\n  constructor(\n    private readonly logger: Logger,\n    private readonly databaseService: DatabaseService,\n  ) {\n    if (!databaseService) {\n      throw new Error(\n        'DatabaseService is required for FlowVersionsService operation. Please update your code to pass a DatabaseService instance.',\n      );\n    }\n  }\n\n  /**\n   * Create flow version\n   */\n  async createFlowVersion(flowId: string, createVersionRequest: CreateFlowVersionRequest) {\n    this.logger.info('Creating flow version', { flowId });\n\n    try {\n      return await this.databaseService.flowVersions.create(flowId, createVersionRequest);\n    } catch (error) {\n      if (error instanceof FlowNotFoundError || error instanceof ValidationError) {\n        throw error;\n      }\n      this.logger.error('Failed to create flow version', { flowId, error });\n      throw new DatabaseError('Failed to create flow version', { error });\n    }\n  }\n\n  /**\n   * Get flow versions\n   */\n  async listFlowVersionsByFlowId(\n    flowId: string,\n    options?: QueryOptions<FlowVersion>,\n  ): Promise<PaginatedResponse<FlowVersion>> {\n    this.logger.debug('Retrieving flow versions', { flowId });\n\n    try {\n      return await this.databaseService.flowVersions.listByFlowId(flowId, options);\n    } catch (error) {\n      if (error instanceof FlowNotFoundError) {\n        throw error;\n      }\n      this.logger.error('Failed to retrieve flow versions', { flowId, error });\n      throw new DatabaseError('Failed to retrieve flow versions', { error });\n    }\n  }\n\n  /**\n   * Get specific flow version by version number or 'latest'\n   */\n  async getFlowVersion(\n    flowId: string,\n    version: string | number | 'latest',\n  ): Promise<FlowVersion | null> {\n    this.logger.debug('Retrieving flow version', { flowId, version });\n\n    try {\n      // Convert string numbers to numbers for the database call\n      let versionParam: number | 'latest';\n      if (version === 'latest') {\n        versionParam = 'latest';\n      } else {\n        const numVersion = typeof version === 'string' ? parseFloat(version) : version;\n        if (isNaN(numVersion)) {\n          throw new ValidationError(`Invalid version format: ${version}`);\n        }\n        versionParam = numVersion;\n      }\n\n      return await this.databaseService.flowVersions.findByKey(flowId, versionParam);\n    } catch (error) {\n      if (error instanceof FlowNotFoundError || error instanceof ValidationError) {\n        throw error;\n      }\n      this.logger.error('Failed to retrieve flow version', { flowId, version, error });\n      throw new DatabaseError('Failed to retrieve flow version', { error });\n    }\n  }\n}\n"],"mappings":";;AAMA,IAAa,sBAAb,MAAiC;CAC/B,YACE,QACA,iBACA;AAFiB,OAAA,SAAA;AACA,OAAA,kBAAA;AAEjB,MAAI,CAAC,gBACH,OAAM,IAAI,MACR,6HACD;;;;;CAOL,MAAM,kBAAkB,QAAgB,sBAAgD;AACtF,OAAK,OAAO,KAAK,yBAAyB,EAAE,QAAQ,CAAC;AAErD,MAAI;AACF,UAAO,MAAM,KAAK,gBAAgB,aAAa,OAAO,QAAQ,qBAAqB;WAC5E,OAAO;AACd,OAAI,iBAAiB,qBAAqB,iBAAiB,gBACzD,OAAM;AAER,QAAK,OAAO,MAAM,iCAAiC;IAAE;IAAQ;IAAO,CAAC;AACrE,SAAM,IAAI,cAAc,iCAAiC,EAAE,OAAO,CAAC;;;;;;CAOvE,MAAM,yBACJ,QACA,SACyC;AACzC,OAAK,OAAO,MAAM,4BAA4B,EAAE,QAAQ,CAAC;AAEzD,MAAI;AACF,UAAO,MAAM,KAAK,gBAAgB,aAAa,aAAa,QAAQ,QAAQ;WACrE,OAAO;AACd,OAAI,iBAAiB,kBACnB,OAAM;AAER,QAAK,OAAO,MAAM,oCAAoC;IAAE;IAAQ;IAAO,CAAC;AACxE,SAAM,IAAI,cAAc,oCAAoC,EAAE,OAAO,CAAC;;;;;;CAO1E,MAAM,eACJ,QACA,SAC6B;AAC7B,OAAK,OAAO,MAAM,2BAA2B;GAAE;GAAQ;GAAS,CAAC;AAEjE,MAAI;GAEF,IAAI;AACJ,OAAI,YAAY,SACd,gBAAe;QACV;IACL,MAAM,aAAa,OAAO,YAAY,WAAW,WAAW,QAAQ,GAAG;AACvE,QAAI,MAAM,WAAW,CACnB,OAAM,IAAI,gBAAgB,2BAA2B,UAAU;AAEjE,mBAAe;;AAGjB,UAAO,MAAM,KAAK,gBAAgB,aAAa,UAAU,QAAQ,aAAa;WACvE,OAAO;AACd,OAAI,iBAAiB,qBAAqB,iBAAiB,gBACzD,OAAM;AAER,QAAK,OAAO,MAAM,mCAAmC;IAAE;IAAQ;IAAS;IAAO,CAAC;AAChF,SAAM,IAAI,cAAc,mCAAmC,EAAE,OAAO,CAAC"}

package/dist/services/flow-versions/schemas-fresh.cjs

@@ -0,0 +1,90 @@
+require("../../_virtual/_rolldown/runtime.cjs");
+const require_types_fresh = require("../../types-fresh.cjs");
+let zod_v4 = require("zod/v4");
+//#region src/services/flow-versions/schemas-fresh.ts
+/**
+// =============================================================================
+// MAPPER CONFIGURATION SCHEMA
+// Per-node data mapper — sandboxed JS expression that reshapes upstream data.
+// If the mapper returns an array, the node auto-iterates over each item.
+// Replaces _loop (will be removed in a future phase).
+// =============================================================================
+
+/**
+* Mapper configuration schema for nodes.
+* When enabled, the JS expression runs against incoming upstream data.
+* Use `return` for multi-statement code; single expressions auto-return.
+*/
+const mapperConfigSchema = zod_v4.z.object({
+	enabled: zod_v4.z.boolean().default(false),
+	expression: zod_v4.z.string().min(1),
+	mode: zod_v4.z.enum([
+		"auto",
+		"iterate",
+		"reshape"
+	]).default("auto"),
+	outputMode: zod_v4.z.enum([
+		"array",
+		"object",
+		"first",
+		"last",
+		"concat"
+	]).default("array"),
+	keyField: zod_v4.z.string().optional(),
+	concurrency: zod_v4.z.number().int().min(1).max(50).default(1),
+	onEmpty: zod_v4.z.enum(["error", "skip"]).default("skip")
+});
+const baseNodeSchema = zod_v4.z.object({
+	id: zod_v4.z.string().min(1, "Node ID is required"),
+	position: zod_v4.z.object({
+		x: zod_v4.z.number(),
+		y: zod_v4.z.number()
+	}).optional(),
+	label: zod_v4.z.string().optional(),
+	referenceId: zod_v4.z.string().optional(),
+	_loop: zod_v4.z.unknown().optional(),
+	mapper: mapperConfigSchema.optional()
+});
+/**
+* Flexible params schema that accepts any key-value pairs.
+* Each node executor validates its own params at runtime using its paramFields definition.
+* This allows the schema to be extensible without code changes when adding new nodes.
+*/
+const flexibleParamsSchema = zod_v4.z.record(zod_v4.z.string(), zod_v4.z.unknown()).default({});
+/**
+* Flow node schema.
+*
+* All nodes share the same base shape with a flexible params record.
+* The `type` field is an arbitrary string – it can be a legacy
+* GraphNodeType enum value (e.g. "AGENT") or an action ID
+* (e.g. "core.model", "gmail.send_message").
+*
+* Runtime validation of params is handled by each node executor /
+* action definition via its `paramFields`.
+*/
+const flowNodeDefinitionsSchema = baseNodeSchema.extend({
+	type: zod_v4.z.string().min(1, "Node type is required"),
+	params: flexibleParamsSchema
+});
+const flowEdgeSchema = zod_v4.z.object({
+	id: zod_v4.z.string().min(1, "Edge ID is required"),
+	source: zod_v4.z.string().min(1, "Edge source is required"),
+	target: zod_v4.z.string().min(1, "Edge target is required"),
+	sourceHandle: zod_v4.z.string().optional(),
+	targetHandle: zod_v4.z.string().optional(),
+	metadata: zod_v4.z.record(zod_v4.z.string(), zod_v4.z.unknown()).optional()
+});
+const invectDefinitionSchema = zod_v4.z.object({
+	nodes: zod_v4.z.array(flowNodeDefinitionsSchema),
+	edges: zod_v4.z.array(flowEdgeSchema),
+	metadata: require_types_fresh.metadataSchema.optional()
+});
+const createFlowVersionRequestSchema = zod_v4.z.object({ invectDefinition: invectDefinitionSchema });
+//#endregion
+exports.createFlowVersionRequestSchema = createFlowVersionRequestSchema;
+exports.flowEdgeSchema = flowEdgeSchema;
+exports.flowNodeDefinitionsSchema = flowNodeDefinitionsSchema;
+exports.invectDefinitionSchema = invectDefinitionSchema;
+exports.mapperConfigSchema = mapperConfigSchema;
+
+//# sourceMappingURL=schemas-fresh.cjs.map

package/dist/services/flow-versions/schemas-fresh.cjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"schemas-fresh.cjs","names":["z","metadataSchema"],"sources":["../../../src/services/flow-versions/schemas-fresh.ts"],"sourcesContent":["import { z } from 'zod/v4';\nimport { metadataSchema } from 'src/types-fresh';\n\n// =============================================================================\n// LOOP CONFIGURATION SCHEMA\n// Generic loop-over capability for any node that accepts input\n// =============================================================================\n\n/**\n// =============================================================================\n// MAPPER CONFIGURATION SCHEMA\n// Per-node data mapper — sandboxed JS expression that reshapes upstream data.\n// If the mapper returns an array, the node auto-iterates over each item.\n// Replaces _loop (will be removed in a future phase).\n// =============================================================================\n\n/**\n * Mapper configuration schema for nodes.\n * When enabled, the JS expression runs against incoming upstream data.\n * Use `return` for multi-statement code; single expressions auto-return.\n */\nexport const mapperConfigSchema = z.object({\n  /** Whether the mapper is enabled for this node. */\n  enabled: z.boolean().default(false),\n\n  /**\n   * JS expression that receives all upstream outputs as local variables.\n   * Executed in a QuickJS sandbox. Use `return` to produce a value.\n   * Single expressions (no `return` keyword) auto-return.\n   *\n   * @example\n   * // Pass array → node iterates per item:\n   * \"users\"\n   *\n   * // Filter then iterate:\n   * \"users.filter(u => u.active)\"\n   *\n   * // Multi-statement with explicit return:\n   * \"const active = users.filter(u => u.active);\\nreturn active.map(u => ({ ...u, rank: 1 }));\"\n   *\n   * // Reshape into object → single run:\n   * \"return { total: orders.reduce((s, o) => s + o.amount, 0), count: orders.length }\"\n   */\n  expression: z.string().min(1),\n\n  /**\n   * Explicit intent declaration — prevents accidental iteration.\n   * - \"auto\"    (default): infer from return type (array → iterate, object → single)\n   * - \"iterate\": assert the result is an array, fail if not\n   * - \"reshape\": assert the result is NOT an array (wrap in object if it is), single run\n   */\n  mode: z.enum(['auto', 'iterate', 'reshape']).default('auto'),\n\n  /**\n   * How to combine iteration results when mapper returns an array.\n   * - \"array\"  (default): collect all outputs into [result1, result2, ...]\n   * - \"object\": build { keyField: result } using a field as key\n   * - \"first\":  return only the first iteration's output\n   * - \"last\":   return only the last iteration's output\n   * - \"concat\": join all string outputs\n   */\n  outputMode: z.enum(['array', 'object', 'first', 'last', 'concat']).default('array'),\n\n  /** For outputMode \"object\": the field path in each result to use as key. */\n  keyField: z.string().optional(),\n\n  /** Max parallel iterations (1 = sequential). Only applies when mapper returns array. */\n  concurrency: z.number().int().min(1).max(50).default(1),\n\n  /**\n   * Behavior when mapper returns an empty array.\n   * - \"skip\":   produce empty output, don't fail (default)\n   * - \"error\":  fail the node\n   */\n  onEmpty: z.enum(['error', 'skip']).default('skip'),\n});\n\nexport type MapperConfig = z.infer<typeof mapperConfigSchema>;\n\nconst baseNodeSchema = z.object({\n  id: z.string().min(1, 'Node ID is required'),\n  position: z\n    .object({\n      x: z.number(),\n      y: z.number(),\n    })\n    .optional(),\n  label: z.string().optional(),\n  referenceId: z.string().optional(), // snake_case unique identifier for input mapping\n  /**\n   * @deprecated Ignored at runtime. Use `mapper` instead. Kept for backward\n   *             compatibility so existing stored flow definitions still parse.\n   */\n  _loop: z.unknown().optional(),\n  /**\n   * Data mapper — sandboxed JS expression that reshapes upstream data\n   * before the node executes. If the expression returns an array, the node\n   * auto-iterates over each element.\n   */\n  mapper: mapperConfigSchema.optional(),\n});\n\n// =============================================================================\n// NODE PARAMS SCHEMA\n// All nodes use a flexible params schema - validation happens at runtime\n// based on each node's paramFields in getDefinition()\n// =============================================================================\n\n/**\n * Flexible params schema that accepts any key-value pairs.\n * Each node executor validates its own params at runtime using its paramFields definition.\n * This allows the schema to be extensible without code changes when adding new nodes.\n */\nconst flexibleParamsSchema = z.record(z.string(), z.unknown()).default({});\n\n// =============================================================================\n// FLOW NODE DEFINITIONS\n// =============================================================================\n\n/**\n * Flow node schema.\n *\n * All nodes share the same base shape with a flexible params record.\n * The `type` field is an arbitrary string – it can be a legacy\n * GraphNodeType enum value (e.g. \"AGENT\") or an action ID\n * (e.g. \"core.model\", \"gmail.send_message\").\n *\n * Runtime validation of params is handled by each node executor /\n * action definition via its `paramFields`.\n */\nexport const flowNodeDefinitionsSchema = baseNodeSchema.extend({\n  type: z.string().min(1, 'Node type is required'),\n  params: flexibleParamsSchema,\n});\n\nexport type FlowNodeDefinitions = z.infer<typeof flowNodeDefinitionsSchema>;\n\n/**\n * Extract a flow-node sub-type.\n *\n * With the move to action-based node types the schema is no longer a\n * discriminated union, so this resolves to the base FlowNodeDefinitions\n * for every `TNodeType`. Kept for API compatibility with the legacy\n * executor (`AgentNodeExecutor`).\n */\nexport type FlowNodeForType<_TNodeType extends string> = FlowNodeDefinitions;\n\nexport const flowEdgeSchema = z.object({\n  id: z.string().min(1, 'Edge ID is required'),\n  source: z.string().min(1, 'Edge source is required'),\n  target: z.string().min(1, 'Edge target is required'),\n  sourceHandle: z.string().optional(),\n  targetHandle: z.string().optional(),\n  metadata: z.record(z.string(), z.unknown()).optional(),\n});\n\nexport type FlowEdge = z.infer<typeof flowEdgeSchema>;\n\nexport const invectDefinitionSchema = z.object({\n  nodes: z.array(flowNodeDefinitionsSchema),\n  edges: z.array(flowEdgeSchema),\n  metadata: metadataSchema.optional(),\n});\n\nexport type InvectDefinition = z.infer<typeof invectDefinitionSchema>;\n\n// Runtime type alias for flow definitions stored in database\nexport type InvectDefinitionRuntime = InvectDefinition;\n\nexport const createFlowVersionRequestSchema = z.object({\n  invectDefinition: invectDefinitionSchema,\n});\n\nexport type CreateFlowVersionRequest = z.infer<typeof createFlowVersionRequestSchema>;\n"],"mappings":";;;;;;;;;;;;;;;;;AAqBA,MAAa,qBAAqBA,OAAAA,EAAE,OAAO;CAEzC,SAASA,OAAAA,EAAE,SAAS,CAAC,QAAQ,MAAM;CAoBnC,YAAYA,OAAAA,EAAE,QAAQ,CAAC,IAAI,EAAE;CAQ7B,MAAMA,OAAAA,EAAE,KAAK;EAAC;EAAQ;EAAW;EAAU,CAAC,CAAC,QAAQ,OAAO;CAU5D,YAAYA,OAAAA,EAAE,KAAK;EAAC;EAAS;EAAU;EAAS;EAAQ;EAAS,CAAC,CAAC,QAAQ,QAAQ;CAGnF,UAAUA,OAAAA,EAAE,QAAQ,CAAC,UAAU;CAG/B,aAAaA,OAAAA,EAAE,QAAQ,CAAC,KAAK,CAAC,IAAI,EAAE,CAAC,IAAI,GAAG,CAAC,QAAQ,EAAE;CAOvD,SAASA,OAAAA,EAAE,KAAK,CAAC,SAAS,OAAO,CAAC,CAAC,QAAQ,OAAO;CACnD,CAAC;AAIF,MAAM,iBAAiBA,OAAAA,EAAE,OAAO;CAC9B,IAAIA,OAAAA,EAAE,QAAQ,CAAC,IAAI,GAAG,sBAAsB;CAC5C,UAAUA,OAAAA,EACP,OAAO;EACN,GAAGA,OAAAA,EAAE,QAAQ;EACb,GAAGA,OAAAA,EAAE,QAAQ;EACd,CAAC,CACD,UAAU;CACb,OAAOA,OAAAA,EAAE,QAAQ,CAAC,UAAU;CAC5B,aAAaA,OAAAA,EAAE,QAAQ,CAAC,UAAU;CAKlC,OAAOA,OAAAA,EAAE,SAAS,CAAC,UAAU;CAM7B,QAAQ,mBAAmB,UAAU;CACtC,CAAC;;;;;;AAaF,MAAM,uBAAuBA,OAAAA,EAAE,OAAOA,OAAAA,EAAE,QAAQ,EAAEA,OAAAA,EAAE,SAAS,CAAC,CAAC,QAAQ,EAAE,CAAC;;;;;;;;;;;;AAiB1E,MAAa,4BAA4B,eAAe,OAAO;CAC7D,MAAMA,OAAAA,EAAE,QAAQ,CAAC,IAAI,GAAG,wBAAwB;CAChD,QAAQ;CACT,CAAC;AAcF,MAAa,iBAAiBA,OAAAA,EAAE,OAAO;CACrC,IAAIA,OAAAA,EAAE,QAAQ,CAAC,IAAI,GAAG,sBAAsB;CAC5C,QAAQA,OAAAA,EAAE,QAAQ,CAAC,IAAI,GAAG,0BAA0B;CACpD,QAAQA,OAAAA,EAAE,QAAQ,CAAC,IAAI,GAAG,0BAA0B;CACpD,cAAcA,OAAAA,EAAE,QAAQ,CAAC,UAAU;CACnC,cAAcA,OAAAA,EAAE,QAAQ,CAAC,UAAU;CACnC,UAAUA,OAAAA,EAAE,OAAOA,OAAAA,EAAE,QAAQ,EAAEA,OAAAA,EAAE,SAAS,CAAC,CAAC,UAAU;CACvD,CAAC;AAIF,MAAa,yBAAyBA,OAAAA,EAAE,OAAO;CAC7C,OAAOA,OAAAA,EAAE,MAAM,0BAA0B;CACzC,OAAOA,OAAAA,EAAE,MAAM,eAAe;CAC9B,UAAUC,oBAAAA,eAAe,UAAU;CACpC,CAAC;AAOF,MAAa,iCAAiCD,OAAAA,EAAE,OAAO,EACrD,kBAAkB,wBACnB,CAAC"}

package/dist/services/flow-versions/schemas-fresh.d.cts

@@ -0,0 +1,201 @@
+import { z } from "zod/v4";
+
+//#region src/services/flow-versions/schemas-fresh.d.ts
+/**
+// =============================================================================
+// MAPPER CONFIGURATION SCHEMA
+// Per-node data mapper — sandboxed JS expression that reshapes upstream data.
+// If the mapper returns an array, the node auto-iterates over each item.
+// Replaces _loop (will be removed in a future phase).
+// =============================================================================
+
+/**
+ * Mapper configuration schema for nodes.
+ * When enabled, the JS expression runs against incoming upstream data.
+ * Use `return` for multi-statement code; single expressions auto-return.
+ */
+declare const mapperConfigSchema: z.ZodObject<{
+  enabled: z.ZodDefault<z.ZodBoolean>;
+  expression: z.ZodString;
+  mode: z.ZodDefault<z.ZodEnum<{
+    auto: "auto";
+    iterate: "iterate";
+    reshape: "reshape";
+  }>>;
+  outputMode: z.ZodDefault<z.ZodEnum<{
+    object: "object";
+    array: "array";
+    concat: "concat";
+    first: "first";
+    last: "last";
+  }>>;
+  keyField: z.ZodOptional<z.ZodString>;
+  concurrency: z.ZodDefault<z.ZodNumber>;
+  onEmpty: z.ZodDefault<z.ZodEnum<{
+    error: "error";
+    skip: "skip";
+  }>>;
+}, z.core.$strip>;
+type MapperConfig = z.infer<typeof mapperConfigSchema>;
+/**
+ * Flow node schema.
+ *
+ * All nodes share the same base shape with a flexible params record.
+ * The `type` field is an arbitrary string – it can be a legacy
+ * GraphNodeType enum value (e.g. "AGENT") or an action ID
+ * (e.g. "core.model", "gmail.send_message").
+ *
+ * Runtime validation of params is handled by each node executor /
+ * action definition via its `paramFields`.
+ */
+declare const flowNodeDefinitionsSchema: z.ZodObject<{
+  id: z.ZodString;
+  position: z.ZodOptional<z.ZodObject<{
+    x: z.ZodNumber;
+    y: z.ZodNumber;
+  }, z.core.$strip>>;
+  label: z.ZodOptional<z.ZodString>;
+  referenceId: z.ZodOptional<z.ZodString>;
+  _loop: z.ZodOptional<z.ZodUnknown>;
+  mapper: z.ZodOptional<z.ZodObject<{
+    enabled: z.ZodDefault<z.ZodBoolean>;
+    expression: z.ZodString;
+    mode: z.ZodDefault<z.ZodEnum<{
+      auto: "auto";
+      iterate: "iterate";
+      reshape: "reshape";
+    }>>;
+    outputMode: z.ZodDefault<z.ZodEnum<{
+      object: "object";
+      array: "array";
+      concat: "concat";
+      first: "first";
+      last: "last";
+    }>>;
+    keyField: z.ZodOptional<z.ZodString>;
+    concurrency: z.ZodDefault<z.ZodNumber>;
+    onEmpty: z.ZodDefault<z.ZodEnum<{
+      error: "error";
+      skip: "skip";
+    }>>;
+  }, z.core.$strip>>;
+  type: z.ZodString;
+  params: z.ZodDefault<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+}, z.core.$strip>;
+type FlowNodeDefinitions = z.infer<typeof flowNodeDefinitionsSchema>;
+/**
+ * Extract a flow-node sub-type.
+ *
+ * With the move to action-based node types the schema is no longer a
+ * discriminated union, so this resolves to the base FlowNodeDefinitions
+ * for every `TNodeType`. Kept for API compatibility with the legacy
+ * executor (`AgentNodeExecutor`).
+ */
+type FlowNodeForType<_TNodeType extends string> = FlowNodeDefinitions;
+declare const flowEdgeSchema: z.ZodObject<{
+  id: z.ZodString;
+  source: z.ZodString;
+  target: z.ZodString;
+  sourceHandle: z.ZodOptional<z.ZodString>;
+  targetHandle: z.ZodOptional<z.ZodString>;
+  metadata: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+}, z.core.$strip>;
+type FlowEdge = z.infer<typeof flowEdgeSchema>;
+declare const invectDefinitionSchema: z.ZodObject<{
+  nodes: z.ZodArray<z.ZodObject<{
+    id: z.ZodString;
+    position: z.ZodOptional<z.ZodObject<{
+      x: z.ZodNumber;
+      y: z.ZodNumber;
+    }, z.core.$strip>>;
+    label: z.ZodOptional<z.ZodString>;
+    referenceId: z.ZodOptional<z.ZodString>;
+    _loop: z.ZodOptional<z.ZodUnknown>;
+    mapper: z.ZodOptional<z.ZodObject<{
+      enabled: z.ZodDefault<z.ZodBoolean>;
+      expression: z.ZodString;
+      mode: z.ZodDefault<z.ZodEnum<{
+        auto: "auto";
+        iterate: "iterate";
+        reshape: "reshape";
+      }>>;
+      outputMode: z.ZodDefault<z.ZodEnum<{
+        object: "object";
+        array: "array";
+        concat: "concat";
+        first: "first";
+        last: "last";
+      }>>;
+      keyField: z.ZodOptional<z.ZodString>;
+      concurrency: z.ZodDefault<z.ZodNumber>;
+      onEmpty: z.ZodDefault<z.ZodEnum<{
+        error: "error";
+        skip: "skip";
+      }>>;
+    }, z.core.$strip>>;
+    type: z.ZodString;
+    params: z.ZodDefault<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+  }, z.core.$strip>>;
+  edges: z.ZodArray<z.ZodObject<{
+    id: z.ZodString;
+    source: z.ZodString;
+    target: z.ZodString;
+    sourceHandle: z.ZodOptional<z.ZodString>;
+    targetHandle: z.ZodOptional<z.ZodString>;
+    metadata: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+  }, z.core.$strip>>;
+  metadata: z.ZodOptional<z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>>;
+}, z.core.$strip>;
+type InvectDefinition = z.infer<typeof invectDefinitionSchema>;
+type InvectDefinitionRuntime = InvectDefinition;
+declare const createFlowVersionRequestSchema: z.ZodObject<{
+  invectDefinition: z.ZodObject<{
+    nodes: z.ZodArray<z.ZodObject<{
+      id: z.ZodString;
+      position: z.ZodOptional<z.ZodObject<{
+        x: z.ZodNumber;
+        y: z.ZodNumber;
+      }, z.core.$strip>>;
+      label: z.ZodOptional<z.ZodString>;
+      referenceId: z.ZodOptional<z.ZodString>;
+      _loop: z.ZodOptional<z.ZodUnknown>;
+      mapper: z.ZodOptional<z.ZodObject<{
+        enabled: z.ZodDefault<z.ZodBoolean>;
+        expression: z.ZodString;
+        mode: z.ZodDefault<z.ZodEnum<{
+          auto: "auto";
+          iterate: "iterate";
+          reshape: "reshape";
+        }>>;
+        outputMode: z.ZodDefault<z.ZodEnum<{
+          object: "object";
+          array: "array";
+          concat: "concat";
+          first: "first";
+          last: "last";
+        }>>;
+        keyField: z.ZodOptional<z.ZodString>;
+        concurrency: z.ZodDefault<z.ZodNumber>;
+        onEmpty: z.ZodDefault<z.ZodEnum<{
+          error: "error";
+          skip: "skip";
+        }>>;
+      }, z.core.$strip>>;
+      type: z.ZodString;
+      params: z.ZodDefault<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+    }, z.core.$strip>>;
+    edges: z.ZodArray<z.ZodObject<{
+      id: z.ZodString;
+      source: z.ZodString;
+      target: z.ZodString;
+      sourceHandle: z.ZodOptional<z.ZodString>;
+      targetHandle: z.ZodOptional<z.ZodString>;
+      metadata: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+    }, z.core.$strip>>;
+    metadata: z.ZodOptional<z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>>;
+  }, z.core.$strip>;
+}, z.core.$strip>;
+type CreateFlowVersionRequest = z.infer<typeof createFlowVersionRequestSchema>;
+//#endregion
+export { CreateFlowVersionRequest, FlowEdge, FlowNodeDefinitions, FlowNodeForType, InvectDefinition, InvectDefinitionRuntime, MapperConfig, createFlowVersionRequestSchema, flowEdgeSchema, flowNodeDefinitionsSchema, invectDefinitionSchema, mapperConfigSchema };
+//# sourceMappingURL=schemas-fresh.d.cts.map

package/dist/services/flow-versions/schemas-fresh.d.cts.map

@@ -0,0 +1 @@
+{"version":3,"file":"schemas-fresh.d.cts","names":[],"sources":["../../../src/services/flow-versions/schemas-fresh.ts"],"mappings":";;;;;AAqBA;;;;;;;;;;;cAAa,kBAAA,EAAkB,CAAA,CAAA,SAAA;;;;;;;;;;;;;;;;;;;;;;KAwDnB,YAAA,GAAe,CAAA,CAAE,KAAA,QAAa,kBAAA;;;;;;;;;;;;cAqD7B,yBAAA,EAAyB,CAAA,CAAA,SAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;KAK1B,mBAAA,GAAsB,CAAA,CAAE,KAAA,QAAa,yBAAA;;;;;;;;;KAUrC,eAAA,8BAA6C,mBAAA;AAAA,cAE5C,cAAA,EAAc,CAAA,CAAA,SAAA;;;;;;;;KASf,QAAA,GAAW,CAAA,CAAE,KAAA,QAAa,cAAA;AAAA,cAEzB,sBAAA,EAAsB,CAAA,CAAA,SAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;KAMvB,gBAAA,GAAmB,CAAA,CAAE,KAAA,QAAa,sBAAA;AAAA,KAGlC,uBAAA,GAA0B,gBAAA;AAAA,cAEzB,8BAAA,EAA8B,CAAA,CAAA,SAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;KAI/B,wBAAA,GAA2B,CAAA,CAAE,KAAA,QAAa,8BAAA"}