plugin-build-visualization-block 0.1.1

package/dist/server/pipeline/validator.js

@@ -0,0 +1,323 @@
+/**
+ * This file is part of the NocoBase (R) project.
+ * Copyright (c) 2020-2024 NocoBase Co., Ltd.
+ * Authors: NocoBase Team.
+ *
+ * This project is dual-licensed under AGPL-3.0 and NocoBase Commercial License.
+ * For more information, please refer to: https://www.nocobase.com/agreement.
+ */
+
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var validator_exports = {};
+__export(validator_exports, {
+  default: () => validator_default,
+  normalizeFieldName: () => normalizeFieldName,
+  validate: () => validate
+});
+module.exports = __toCommonJS(validator_exports);
+const normalizeFieldName = (name = "") => name.replace(/[^a-zA-Z0-9]/g, "").toLowerCase();
+const NUMERIC_FIELD_TYPES = /* @__PURE__ */ new Set(["integer", "bigInt", "float", "double", "decimal", "real", "number"]);
+const NUMERIC_INTERFACES = /* @__PURE__ */ new Set(["integer", "number", "percent", "currency", "formula"]);
+const DIMENSION_FIELD_TYPES = /* @__PURE__ */ new Set(["string", "text", "date", "dateOnly", "datetime", "boolean"]);
+const DIMENSION_INTERFACES = /* @__PURE__ */ new Set([
+  "select",
+  "radioGroup",
+  "input",
+  "checkbox",
+  "multipleSelect",
+  "createdAt",
+  "updatedAt",
+  "datetime",
+  "date"
+]);
+const DATE_FIELD_TYPES = /* @__PURE__ */ new Set(["date", "dateOnly", "datetime"]);
+const DATE_INTERFACES = /* @__PURE__ */ new Set(["createdAt", "updatedAt", "datetime", "date"]);
+const RECORD_MATCH_NAMES = /* @__PURE__ */ new Set(["id", "uid", "uuid", "key"]);
+const isNumericField = (meta) => NUMERIC_FIELD_TYPES.has(meta.type) || NUMERIC_INTERFACES.has(meta.interface);
+const isDimensionField = (meta) => DIMENSION_FIELD_TYPES.has(meta.type) || DIMENSION_INTERFACES.has(meta.interface);
+const isDateField = (meta) => DATE_FIELD_TYPES.has(meta.type) || DATE_INTERFACES.has(meta.interface);
+function buildIndexes(summary) {
+  const indexes = /* @__PURE__ */ new Map();
+  for (const collection of summary.collections) {
+    const exact = /* @__PURE__ */ new Set();
+    const normalized = /* @__PURE__ */ new Map();
+    const byName = /* @__PURE__ */ new Map();
+    for (const field of collection.fields) {
+      if (!field.name) {
+        continue;
+      }
+      exact.add(field.name);
+      byName.set(field.name, field);
+      const key = normalizeFieldName(field.name);
+      if (key && !normalized.has(key)) {
+        normalized.set(key, field.name);
+      }
+    }
+    indexes.set(collection.name, { exact, normalized, byName });
+  }
+  return indexes;
+}
+function splitRef(rawRef, primaryCollection, indexes) {
+  const dot = rawRef.indexOf(".");
+  if (dot > 0) {
+    const head = rawRef.slice(0, dot);
+    if (indexes.has(head)) {
+      return { collection: head, field: rawRef.slice(dot + 1), qualified: true };
+    }
+  }
+  return { collection: primaryCollection, field: rawRef, qualified: false };
+}
+function isCompatible(meta, usage) {
+  if (usage.kind === "list") {
+    return true;
+  }
+  if (usage.kind === "dimension") {
+    return isDimensionField(meta);
+  }
+  if (usage.aggregation && usage.aggregation !== "count") {
+    return isNumericField(meta);
+  }
+  return true;
+}
+function tryTypeCompatibleRemap(index, _field, usage) {
+  var _a, _b, _c;
+  if (usage.kind === "list") {
+    return void 0;
+  }
+  const candidates = Array.from(index.byName.values());
+  if (usage.kind === "measure") {
+    if (usage.aggregation && usage.aggregation !== "count") {
+      return (_a = candidates.find(isNumericField)) == null ? void 0 : _a.name;
+    }
+    const record = candidates.find((meta) => RECORD_MATCH_NAMES.has(normalizeFieldName(meta.name)));
+    return (_b = record ?? candidates[0]) == null ? void 0 : _b.name;
+  }
+  const dated = candidates.find(isDateField);
+  if (dated) {
+    return dated.name;
+  }
+  return (_c = candidates.find(isDimensionField)) == null ? void 0 : _c.name;
+}
+function tryRemap(index, field, usage) {
+  if (!field) {
+    return void 0;
+  }
+  const byName = index.normalized.get(normalizeFieldName(field));
+  if (byName) {
+    return { name: byName, reason: "case-insensitive name match" };
+  }
+  const typed = tryTypeCompatibleRemap(index, field, usage);
+  if (typed) {
+    return { name: typed, reason: "type-compatible remap" };
+  }
+  return void 0;
+}
+function classifyRef(rawRef, primaryCollection, indexes, usage) {
+  const { collection, field, qualified } = splitRef(rawRef, primaryCollection, indexes);
+  const index = indexes.get(collection);
+  if (!index) {
+    return { kind: "unresolved" };
+  }
+  if (field && index.exact.has(field)) {
+    return { kind: "kept" };
+  }
+  const remap = tryRemap(index, field, usage);
+  if (remap) {
+    const replacement = qualified ? `${collection}.${remap.name}` : remap.name;
+    return { kind: "remapped", replacement, reason: remap.reason };
+  }
+  return { kind: "unresolved" };
+}
+function reconcileStringList(list, primaryCollection, indexes, adjustments) {
+  const result = [];
+  for (const ref of list) {
+    const resolution = classifyRef(ref, primaryCollection, indexes, { kind: "list" });
+    if (resolution.kind === "kept") {
+      result.push(ref);
+    } else if (resolution.kind === "remapped") {
+      result.push(resolution.replacement);
+      adjustments.push({
+        reference: ref,
+        action: "remapped",
+        replacement: resolution.replacement,
+        reason: resolution.reason
+      });
+    } else {
+      adjustments.push({ reference: ref, action: "removed", reason: "field does not exist" });
+    }
+  }
+  return result;
+}
+function reconcileDimensions(dimensions, primaryCollection, indexes, adjustments) {
+  const result = [];
+  for (const dimension of dimensions) {
+    const resolution = classifyRef(dimension.field, primaryCollection, indexes, { kind: "dimension" });
+    if (resolution.kind === "kept") {
+      result.push(dimension);
+    } else if (resolution.kind === "remapped") {
+      result.push({ ...dimension, field: resolution.replacement });
+      adjustments.push({
+        reference: dimension.field,
+        action: "remapped",
+        replacement: resolution.replacement,
+        reason: resolution.reason
+      });
+    } else {
+      adjustments.push({ reference: dimension.field, action: "removed", reason: "field does not exist" });
+    }
+  }
+  return result;
+}
+function reconcileMeasures(measures, primaryCollection, indexes, adjustments) {
+  const result = [];
+  for (const measure of measures) {
+    const usage = { kind: "measure", aggregation: measure.aggregation };
+    const resolution = classifyRef(measure.field, primaryCollection, indexes, usage);
+    if (resolution.kind === "kept") {
+      result.push(measure);
+    } else if (resolution.kind === "remapped") {
+      result.push({ ...measure, field: resolution.replacement });
+      adjustments.push({
+        reference: measure.field,
+        action: "remapped",
+        replacement: resolution.replacement,
+        reason: resolution.reason
+      });
+    } else {
+      adjustments.push({
+        reference: measure.field,
+        action: "removed",
+        reason: "no compatible field for measure"
+      });
+    }
+  }
+  return result;
+}
+function reconcileChart(chart, primaryCollection, indexes, adjustments) {
+  const next = {
+    ...chart,
+    measures: reconcileMeasures(chart.measures, primaryCollection, indexes, adjustments)
+  };
+  if (chart.dimensions) {
+    next.dimensions = reconcileDimensions(chart.dimensions, primaryCollection, indexes, adjustments);
+  }
+  return next;
+}
+function enforceRequiredRoles(spec, next, adjustments) {
+  let unmet = false;
+  const flag = (reference, reason) => {
+    adjustments.push({ reference, action: "unmet-role", reason });
+    unmet = true;
+  };
+  if (spec.blockType === "chart") {
+    const charts = next.charts ?? [];
+    if (charts.length === 0) {
+      flag("chart", "no chart could be produced");
+    }
+    for (const chart of charts) {
+      if (chart.measures.length === 0) {
+        flag(`chart:${chart.key}`, "required measure has no compatible field");
+      }
+    }
+  } else if (next.charts) {
+    for (const chart of next.charts) {
+      if (chart.measures.length === 0) {
+        flag(`chart:${chart.key}`, "required measure has no compatible field");
+      }
+    }
+  }
+  if (spec.blockType === "table") {
+    if (!next.table || next.table.fields.length === 0) {
+      flag("table.fields", "no usable fields remain for the table");
+    }
+  } else if (next.table && next.table.fields.length === 0) {
+    flag("table.fields", "no usable fields remain for the table");
+  }
+  if (spec.blockType === "form") {
+    if (!next.form || next.form.fields.length === 0) {
+      flag("form.fields", "no usable fields remain for the form");
+    }
+  } else if (next.form && next.form.fields.length === 0) {
+    flag("form.fields", "no usable fields remain for the form");
+  }
+  return unmet;
+}
+function summarize(adjustments, usedFallback) {
+  let removedCount = 0;
+  let remappedCount = 0;
+  const unmetRoles = [];
+  for (const adjustment of adjustments) {
+    if (adjustment.action === "removed") {
+      removedCount += 1;
+    } else if (adjustment.action === "remapped") {
+      remappedCount += 1;
+    } else {
+      unmetRoles.push(adjustment.reference);
+    }
+  }
+  return {
+    outcome: usedFallback ? "fallback" : "validated",
+    removedCount,
+    remappedCount,
+    unmetRoles
+  };
+}
+function validate(spec, summary) {
+  const indexes = buildIndexes(summary);
+  const adjustments = [];
+  const primaryCollection = spec.primaryCollection;
+  const primaryIndex = indexes.get(primaryCollection);
+  const primarySummary = summary.collections.find((collection) => collection.name === primaryCollection);
+  const primaryUnavailable = !primaryIndex || (primarySummary == null ? void 0 : primarySummary.introspectionFailed) === true;
+  if (primaryUnavailable) {
+    adjustments.push({
+      reference: primaryCollection,
+      action: "unmet-role",
+      reason: "schema unavailable"
+    });
+    return { spec, adjustments, usedFallback: true, summary: summarize(adjustments, true) };
+  }
+  const next = { ...spec };
+  if (spec.charts) {
+    next.charts = spec.charts.map((chart) => reconcileChart(chart, primaryCollection, indexes, adjustments));
+  }
+  if (spec.table) {
+    next.table = {
+      ...spec.table,
+      fields: reconcileStringList(spec.table.fields, primaryCollection, indexes, adjustments)
+    };
+    if (spec.table.sortable) {
+      next.table.sortable = reconcileStringList(spec.table.sortable, primaryCollection, indexes, adjustments);
+    }
+  }
+  if (spec.form) {
+    next.form = {
+      ...spec.form,
+      fields: reconcileStringList(spec.form.fields, primaryCollection, indexes, adjustments)
+    };
+  }
+  const usedFallback = enforceRequiredRoles(spec, next, adjustments);
+  return { spec: next, adjustments, usedFallback, summary: summarize(adjustments, usedFallback) };
+}
+var validator_default = validate;
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  normalizeFieldName,
+  validate
+});

package/dist/server/plugin.js

@@ -0,0 +1,210 @@
+/**
+ * This file is part of the NocoBase (R) project.
+ * Copyright (c) 2020-2024 NocoBase Co., Ltd.
+ * Authors: NocoBase Team.
+ *
+ * This project is dual-licensed under AGPL-3.0 and NocoBase Commercial License.
+ * For more information, please refer to: https://www.nocobase.com/agreement.
+ */
+
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var plugin_exports = {};
+__export(plugin_exports, {
+  PluginBuildVisualizationBlockServer: () => PluginBuildVisualizationBlockServer,
+  default: () => plugin_default
+});
+module.exports = __toCommonJS(plugin_exports);
+var import_server = require("@nocobase/server");
+var import_path = require("path");
+var import_constants = require("../shared/constants");
+var import_build = require("./actions/build");
+var import_settings = __toESM(require("./resource/settings"));
+var import_tools = require("./tools");
+class PluginBuildVisualizationBlockServer extends import_server.Plugin {
+  schemaCollections = [import_constants.COLLECTION_NAME, import_constants.SETTINGS_COLLECTION_NAME];
+  afterAdd() {
+  }
+  async beforeLoad() {
+    await this.db.import({
+      directory: (0, import_path.resolve)(__dirname, "collections")
+    });
+  }
+  async load() {
+    this.app.resourceManager.registerActionHandlers({
+      "aiVisualizationBuilds:build": import_build.build,
+      "aiVisualizationBuilds:retry": import_build.retry,
+      "aiVisualizationBuilds:getResult": import_build.getResult
+    });
+    this.app.resourceManager.define(import_settings.default);
+    this.app.acl.allow("aiVisualizationBuilds", "getResult", "loggedIn");
+    this.app.acl.allow(import_constants.SETTINGS_COLLECTION_NAME, "publicGet", "loggedIn");
+    this.app.acl.registerSnippet({
+      name: "pm.ai-build-visualization",
+      actions: [
+        "aiVisualizationBuilds:create",
+        "aiVisualizationBuilds:update",
+        "aiVisualizationBuilds:destroy",
+        "aiVisualizationBuilds:list",
+        "aiVisualizationBuilds:get",
+        "aiVisualizationBuilds:build",
+        "aiVisualizationBuilds:retry",
+        "aiVisualizationBuilds:getResult"
+      ]
+    });
+    this.app.acl.registerSnippet({
+      name: "pm.plugin-build-visualization-block.settings",
+      actions: [`${import_constants.SETTINGS_COLLECTION_NAME}:get`, `${import_constants.SETTINGS_COLLECTION_NAME}:update`]
+    });
+    (0, import_build.registerBuildQueue)(this.app);
+    this.app.on("afterStart", async () => {
+      (0, import_build.startBuildQueueProcessor)(this.app);
+      try {
+        await (0, import_build.recoverInterruptedBuilds)(this.app);
+      } catch (err) {
+        this.app.logger.warn("[plugin-build-visualization-block] Failed to recover interrupted builds", err);
+      }
+    });
+    this.app.on("beforeStop", () => {
+      (0, import_build.unregisterBuildQueue)(this.app);
+    });
+    this.app.on("beforeDestroy", () => {
+      (0, import_build.unregisterBuildQueue)(this.app);
+    });
+    this.registerAITools();
+  }
+  /**
+   * Register the `build_visualization_block` AI tool through the AI plugin's
+   * tools manager so an AI chat agent can initiate a build. The AI subsystem is
+   * untyped against the server core, so the manager is resolved through a
+   * narrow cast and guarded for absence (the plugin must not hard-depend on the
+   * AI plugin being installed).
+   */
+  registerAITools() {
+    var _a;
+    const toolsManager = (_a = this.app.aiManager) == null ? void 0 : _a.toolsManager;
+    if (!toolsManager) {
+      this.app.logger.warn(
+        "[plugin-build-visualization-block] aiManager.toolsManager is not available; skipping tool registration"
+      );
+      return;
+    }
+    const tools = [import_tools.buildVisualizationBlockTool];
+    toolsManager.registerTools(
+      tools.map((item) => {
+        const name = `${item.groupName}-${item.tool.name}`;
+        return {
+          scope: "CUSTOM",
+          defaultPermission: item.tool.execution === "backend" ? "ALLOW" : "ASK",
+          execution: item.tool.execution,
+          introduction: {
+            title: item.tool.title,
+            about: item.tool.description
+          },
+          definition: {
+            name,
+            description: item.tool.description,
+            schema: item.tool.schema
+          },
+          invoke: item.tool.invoke
+        };
+      })
+    );
+  }
+  async ensureCollectionSchema(collectionName) {
+    const collection = this.db.getCollection(collectionName);
+    if (!collection) {
+      this.app.logger.warn(`[plugin-build-visualization-block] Collection "${collectionName}" is not registered`);
+      return;
+    }
+    const queryInterface = this.db.sequelize.getQueryInterface();
+    const tableName = collection.getTableNameWithSchema();
+    let columns = null;
+    try {
+      columns = await queryInterface.describeTable(tableName);
+    } catch (error) {
+      await collection.model.sync();
+      columns = await queryInterface.describeTable(tableName);
+    }
+    const attributes = collection.model.rawAttributes;
+    for (const [attributeName, attribute] of Object.entries(attributes)) {
+      const columnName = attribute.field || attributeName;
+      if (columns[columnName]) {
+        continue;
+      }
+      const columnDefinition = { ...attribute };
+      delete columnDefinition.Model;
+      delete columnDefinition.fieldName;
+      await queryInterface.addColumn(
+        tableName,
+        columnName,
+        columnDefinition
+      );
+      columns[columnName] = columnDefinition;
+      this.app.logger.info(
+        `[plugin-build-visualization-block] Added missing column "${columnName}" to "${collectionName}"`
+      );
+    }
+  }
+  async ensureSchema() {
+    for (const collectionName of this.schemaCollections) {
+      await this.ensureCollectionSchema(collectionName);
+    }
+    const repo = this.db.getRepository("collections");
+    if (repo) {
+      for (const collectionName of this.schemaCollections) {
+        await repo.db2cm(collectionName);
+      }
+    }
+  }
+  async install(options) {
+    await this.ensureSchema();
+  }
+  async upgrade() {
+    await this.ensureSchema();
+  }
+  async afterEnable() {
+  }
+  async beforeDisable() {
+    (0, import_build.unregisterBuildQueue)(this.app);
+  }
+  async afterDisable() {
+    (0, import_build.unregisterBuildQueue)(this.app);
+  }
+  async beforeUnload() {
+    (0, import_build.unregisterBuildQueue)(this.app);
+  }
+  async remove() {
+    (0, import_build.unregisterBuildQueue)(this.app);
+  }
+}
+var plugin_default = PluginBuildVisualizationBlockServer;
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  PluginBuildVisualizationBlockServer
+});

package/dist/server/resource/settings.js

@@ -0,0 +1,106 @@
+/**
+ * This file is part of the NocoBase (R) project.
+ * Copyright (c) 2020-2024 NocoBase Co., Ltd.
+ * Authors: NocoBase Team.
+ *
+ * This project is dual-licensed under AGPL-3.0 and NocoBase Commercial License.
+ * For more information, please refer to: https://www.nocobase.com/agreement.
+ */
+
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var settings_exports = {};
+__export(settings_exports, {
+  aiVisualizationBuildSettings: () => aiVisualizationBuildSettings,
+  default: () => settings_default
+});
+module.exports = __toCommonJS(settings_exports);
+var import_constants = require("../../shared/constants");
+const DEFAULT_SETTINGS = {
+  defaultCollections: [],
+  enableAITool: true
+};
+function readRecordValue(record, key) {
+  if (typeof record.get === "function") {
+    return record.get(key);
+  }
+  return record[key];
+}
+function normalizeCollections(value) {
+  if (!Array.isArray(value)) {
+    return [];
+  }
+  return value.filter((item) => typeof item === "string" && item.length > 0).slice(0, import_constants.MAX_COLLECTIONS);
+}
+function normalizeOptionalString(value) {
+  return typeof value === "string" && value.trim() ? value.trim() : null;
+}
+function serializeSettings(record) {
+  return {
+    defaultDataSource: normalizeOptionalString(readRecordValue(record, "defaultDataSource")),
+    defaultCollections: normalizeCollections(readRecordValue(record, "defaultCollections")),
+    defaultLLMService: normalizeOptionalString(readRecordValue(record, "defaultLLMService")),
+    defaultModel: normalizeOptionalString(readRecordValue(record, "defaultModel")),
+    enableAITool: readRecordValue(record, "enableAITool") !== false
+  };
+}
+function sanitizeValues(values) {
+  const source = values && typeof values === "object" ? values : {};
+  return {
+    defaultDataSource: normalizeOptionalString(source.defaultDataSource),
+    defaultCollections: normalizeCollections(source.defaultCollections),
+    defaultLLMService: normalizeOptionalString(source.defaultLLMService),
+    defaultModel: normalizeOptionalString(source.defaultModel),
+    enableAITool: source.enableAITool !== false
+  };
+}
+async function getSettings(ctx) {
+  const repo = ctx.db.getRepository(import_constants.SETTINGS_COLLECTION_NAME);
+  const existing = await repo.findOne();
+  if (existing) {
+    return existing;
+  }
+  return repo.create({ values: DEFAULT_SETTINGS });
+}
+const aiVisualizationBuildSettings = {
+  name: import_constants.SETTINGS_COLLECTION_NAME,
+  actions: {
+    get: async (ctx, next) => {
+      const settings = await getSettings(ctx);
+      ctx.body = serializeSettings(settings);
+      await next();
+    },
+    publicGet: async (ctx, next) => {
+      const settings = await getSettings(ctx);
+      ctx.body = serializeSettings(settings);
+      await next();
+    },
+    update: async (ctx, next) => {
+      const settings = await getSettings(ctx);
+      const nextValues = sanitizeValues(ctx.action.params.values);
+      await settings.update(nextValues);
+      ctx.body = nextValues;
+      await next();
+    }
+  }
+};
+var settings_default = aiVisualizationBuildSettings;
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  aiVisualizationBuildSettings
+});