davinci-resolve-mcp 2.57.4 → 2.58.0

package/resolve-advanced/vendor/drx-codec/node-layout.js

@@ -0,0 +1,249 @@
+/**
+ * Node-graph LAYOUT rewriter — repositions nodes in a DRX/LmVersion grade Body
+ * without touching any grade content.
+ *
+ * A grade Body is [0x81] + zstd(protobuf). Inside the protobuf, each F1 container
+ * holds F7 node messages whose F4 (xPos) / F5 (yPos) varints are the node-editor
+ * layout. Resolve's own "Cleanup Node Graph" rewrites ONLY those two fields
+ * (verified by before/after Project.db diff, 2026-07): its clean layout is an
+ * evenly spaced single row (observed x = 290/786/1280 at y = 428 for 3 nodes).
+ *
+ * This module replicates that: every byte other than the F4/F5 varints (and the
+ * containing length prefixes) survives verbatim, so the rewrite is lossless for
+ * OFX/uncalibrated params, keyframes, labels — everything.
+ *
+ * Consumed by the drx tool's `relayout` action (live single-shot path: grab →
+ * relayout → ApplyGradeFromDRX) and project_db's `relayout_node_graphs`
+ * (closed-project bulk patch of ListMgt::LmVersion rows).
+ */
+
+'use strict';
+
+const nodeZlib = require('zlib');
+
+// Same zstd backend priority as drx-generator.js: native node:zlib (Node 22+),
+// zstd-codec (WASM), fzstd (decompress-only — compress throws clearly).
+const HAS_NATIVE_ZSTD =
+  typeof nodeZlib.zstdCompressSync === 'function' && typeof nodeZlib.zstdDecompressSync === 'function';
+
+let ZstdCodec = null;
+try {
+  ZstdCodec = require('zstd-codec').ZstdCodec;
+} catch {
+  /* optional */
+}
+
+let backend = null;
+async function getZstd() {
+  if (backend) return backend;
+  if (HAS_NATIVE_ZSTD) {
+    backend = {
+      decompress: (data) => nodeZlib.zstdDecompressSync(Buffer.from(data)),
+      compress: (data) => nodeZlib.zstdCompressSync(Buffer.from(data)),
+    };
+    return backend;
+  }
+  if (ZstdCodec) {
+    backend = await new Promise((resolve) => {
+      ZstdCodec.run((zstd) => {
+        const simple = new zstd.Simple();
+        resolve({
+          decompress: (data) => Buffer.from(simple.decompress(new Uint8Array(data))),
+          compress: (data) => Buffer.from(simple.compress(new Uint8Array(data))),
+        });
+      });
+    });
+    return backend;
+  }
+  const fzstd = require('fzstd');
+  backend = {
+    decompress: (data) => Buffer.from(fzstd.decompress(new Uint8Array(data))),
+    compress: () => {
+      throw new Error('no zstd compressor available (need Node 22+ zlib zstd or zstd-codec)');
+    },
+  };
+  return backend;
+}
+
+// ---- minimal protobuf walker (varint + length-delimited only, as the Body uses) ----
+
+function readVarint(buf, p) {
+  let v = 0n;
+  let s = 0n;
+  let i = p;
+  for (;;) {
+    const b = buf[i++];
+    v |= BigInt(b & 0x7f) << s;
+    if (!(b & 0x80)) break;
+    s += 7n;
+  }
+  return [v, i];
+}
+
+function encodeVarint(v) {
+  v = BigInt(v);
+  const out = [];
+  while (v > 0x7fn) {
+    out.push(Number(v & 0x7fn) | 0x80);
+    v >>= 7n;
+  }
+  out.push(Number(v));
+  return Buffer.from(out);
+}
+
+/** Decode one message level into {f, wt, start, end, val} field records. */
+function fields(buf) {
+  const out = [];
+  let p = 0;
+  while (p < buf.length) {
+    const start = p;
+    let tag;
+    [tag, p] = readVarint(buf, p);
+    const f = Number(tag >> 3n);
+    const wt = Number(tag & 7n);
+    let end = p;
+    let val = null;
+    if (wt === 0) [val, end] = readVarint(buf, p);
+    else if (wt === 1) end = p + 8;
+    else if (wt === 5) end = p + 4;
+    else if (wt === 2) {
+      let len;
+      [len, p] = readVarint(buf, p);
+      end = p + Number(len);
+      val = buf.subarray(p, end);
+    } else throw new Error(`unsupported wire type ${wt} at offset ${start}`);
+    if (end > buf.length) throw new Error('truncated protobuf');
+    out.push({ f, wt, start, end, val });
+    p = end;
+  }
+  return out;
+}
+
+// Node message field numbers (see DRX-VALUE-SCALING.md / calibration notes):
+// F4 = xPos varint, F5 = yPos varint.
+const F_NODE = 7; // node message inside the F1 container
+const F_X = 4;
+const F_Y = 5;
+
+/**
+ * Resolve-cleanup-style positions for n nodes: one evenly spaced row.
+ * Defaults are the exact values Resolve's own Cleanup Node Graph produced
+ * (3-node measurement); spacing stays fixed rather than adapting to n so the
+ * result matches native cleanup for typical graphs.
+ */
+function cleanRowPositions(n, { originX = 290, originY = 428, spacingX = 495 } = {}) {
+  return Array.from({ length: n }, (_, i) => [originX + i * spacingX, originY]);
+}
+
+/** Rewrite F4/F5 in one node message buffer; appends them if absent. */
+function rewriteNodeMessage(nodeBuf, x, y) {
+  const parts = [];
+  let sawX = false;
+  let sawY = false;
+  for (const h of fields(nodeBuf)) {
+    if (h.f === F_X && h.wt === 0) {
+      sawX = true;
+      parts.push(encodeVarint((F_X << 3) | 0), encodeVarint(x));
+    } else if (h.f === F_Y && h.wt === 0) {
+      sawY = true;
+      parts.push(encodeVarint((F_Y << 3) | 0), encodeVarint(y));
+    } else {
+      parts.push(nodeBuf.subarray(h.start, h.end));
+    }
+  }
+  if (!sawX) parts.push(encodeVarint((F_X << 3) | 0), encodeVarint(x));
+  if (!sawY) parts.push(encodeVarint((F_Y << 3) | 0), encodeVarint(y));
+  return Buffer.concat(parts);
+}
+
+/**
+ * Reposition every node in a grade Body.
+ *
+ * @param {Buffer} body — raw Body blob: 0x81 magic + zstd(protobuf)
+ * @param {Object} [options]
+ * @param {Array<[number,number]>} [options.positions] — explicit [x,y] per node
+ *   (encounter order = node index order); omit for the clean-row layout.
+ * @param {number} [options.originX] @param {number} [options.originY]
+ * @param {number} [options.spacingX] — clean-row tuning when positions omitted.
+ * @returns {Promise<{body: Buffer, nodeCount: number, positions: Array<[number,number]>}>}
+ */
+async function relayoutBody(body, options = {}) {
+  if (!Buffer.isBuffer(body)) body = Buffer.from(body);
+  if (body[0] !== 0x81) throw new Error('not a grade Body (missing 0x81 magic)');
+  const zstd = await getZstd();
+  const proto = zstd.decompress(body.subarray(1));
+
+  // First pass: count nodes so the default layout can be sized.
+  const top = fields(proto);
+  let nodeCount = 0;
+  for (const t of top) {
+    if (t.f === 1 && t.wt === 2) for (const g of fields(t.val)) if (g.f === F_NODE && g.wt === 2) nodeCount++;
+  }
+  if (nodeCount === 0) throw new Error('relayout refused: Body decodes to 0 nodes');
+
+  const positions = options.positions || cleanRowPositions(nodeCount, options);
+  if (positions.length < nodeCount) {
+    throw new Error(`positions has ${positions.length} entries but the grade has ${nodeCount} nodes`);
+  }
+  for (const [x, y] of positions.slice(0, nodeCount)) {
+    if (!Number.isInteger(x) || !Number.isInteger(y) || x < 0 || y < 0) {
+      throw new Error('positions must be non-negative integers (protobuf varints)');
+    }
+  }
+
+  // Second pass: rebuild, rewriting each node message and re-lengthing its containers.
+  let nodeIdx = 0;
+  const rebuilt = [];
+  for (const t of top) {
+    if (t.f === 1 && t.wt === 2) {
+      const innerParts = [];
+      for (const g of fields(t.val)) {
+        if (g.f === F_NODE && g.wt === 2) {
+          const [x, y] = positions[nodeIdx++];
+          const newNode = rewriteNodeMessage(g.val, x, y);
+          innerParts.push(encodeVarint((F_NODE << 3) | 2), encodeVarint(newNode.length), newNode);
+        } else {
+          innerParts.push(t.val.subarray(g.start, g.end));
+        }
+      }
+      const newInner = Buffer.concat(innerParts);
+      rebuilt.push(encodeVarint((1 << 3) | 2), encodeVarint(newInner.length), newInner);
+    } else {
+      rebuilt.push(proto.subarray(t.start, t.end));
+    }
+  }
+
+  const out = Buffer.concat([Buffer.from([0x81]), zstd.compress(Buffer.concat(rebuilt))]);
+  return { body: out, nodeCount, positions: positions.slice(0, nodeCount) };
+}
+
+/** Hex-string convenience wrapper (DRX <Body> / DB dumps are handled as hex upstream). */
+async function relayoutBodyHex(bodyHex, options = {}) {
+  const r = await relayoutBody(Buffer.from(bodyHex.trim(), 'hex'), options);
+  return { ...r, bodyHex: r.body.toString('hex') };
+}
+
+/** Decode just the node positions from a Body (for dry runs / verification). */
+async function readNodePositions(body) {
+  if (!Buffer.isBuffer(body)) body = Buffer.from(body);
+  if (body[0] !== 0x81) throw new Error('not a grade Body (missing 0x81 magic)');
+  const zstd = await getZstd();
+  const proto = zstd.decompress(body.subarray(1));
+  const positions = [];
+  for (const t of fields(proto)) {
+    if (t.f !== 1 || t.wt !== 2) continue;
+    for (const g of fields(t.val)) {
+      if (g.f !== F_NODE || g.wt !== 2) continue;
+      let x = null;
+      let y = null;
+      for (const h of fields(g.val)) {
+        if (h.f === F_X && h.wt === 0) x = Number(h.val);
+        if (h.f === F_Y && h.wt === 0) y = Number(h.val);
+      }
+      positions.push([x, y]);
+    }
+  }
+  return positions;
+}
+
+module.exports = { relayoutBody, relayoutBodyHex, readNodePositions, cleanRowPositions };

package/resolve-advanced/vendor/drx-codec/resolved-drx-generator.js

@@ -0,0 +1,393 @@
+/**
+ * Resolved DRX Generator
+ *
+ * Integrates the Tool Resolver with the DRX Generator to provide
+ * intent-aware, tool-selection-based grade creation.
+ *
+ * This module wraps the existing drx-generator.js with tool resolution,
+ * ensuring that:
+ * - Contrast uses the appropriate tool (Lift/Gain vs. Contrast Corrector)
+ * - Exposure uses proper compensation (Offset vs. Gain)
+ * - Temperature uses the right approach (global vs. split)
+ * - User preferences are respected
+ *
+ * @module drx/resolved-drx-generator
+ */
+
+const toolResolver = require('./tool-resolver');
+const vocabularyIntents = require('./vocabulary-intents');
+const drxGenerator = require('./drx-generator');
+
+// ═══════════════════════════════════════════════════════════════════════════════
+// RESOLVED PARAMETER CONVERSION
+// ═══════════════════════════════════════════════════════════════════════════════
+
+/**
+ * Convert tool-resolved parameters to DRX generator format
+ * The tool resolver outputs structured params, this converts them to flat format
+ *
+ * @param {Object} resolved - Output from toolResolver.resolve()
+ * @returns {Object} Flat parameter object for DRX generator
+ */
+function convertResolvedToFlat(resolved) {
+  const flat = {};
+  const params = resolved.params || {};
+
+  // ═══════════════════════════════════════════════════════════════════════════
+  // Primary Wheels (Lift/Gamma/Gain)
+  // ═══════════════════════════════════════════════════════════════════════════
+
+  // Lift
+  if (params.liftR !== undefined) flat.liftR = params.liftR;
+  if (params.liftG !== undefined) flat.liftG = params.liftG;
+  if (params.liftB !== undefined) flat.liftB = params.liftB;
+  if (params.liftMaster !== undefined) flat.liftMaster = params.liftMaster;
+
+  // Gamma
+  if (params.gammaR !== undefined) flat.gammaR = params.gammaR;
+  if (params.gammaG !== undefined) flat.gammaG = params.gammaG;
+  if (params.gammaB !== undefined) flat.gammaB = params.gammaB;
+  if (params.gammaMaster !== undefined) flat.gammaMaster = params.gammaMaster;
+
+  // Gain
+  if (params.gainR !== undefined) flat.gainR = params.gainR;
+  if (params.gainG !== undefined) flat.gainG = params.gainG;
+  if (params.gainB !== undefined) flat.gainB = params.gainB;
+  if (params.gainMaster !== undefined) flat.gainMaster = params.gainMaster;
+
+  // Offset
+  if (params.offsetR !== undefined) flat.offsetR = params.offsetR;
+  if (params.offsetG !== undefined) flat.offsetG = params.offsetG;
+  if (params.offsetB !== undefined) flat.offsetB = params.offsetB;
+
+  // ═══════════════════════════════════════════════════════════════════════════
+  // Log Wheels
+  // ═══════════════════════════════════════════════════════════════════════════
+
+  if (params.logShadowR !== undefined) flat.logShadowR = params.logShadowR;
+  if (params.logShadowG !== undefined) flat.logShadowG = params.logShadowG;
+  if (params.logShadowB !== undefined) flat.logShadowB = params.logShadowB;
+  if (params.logMidR !== undefined) flat.logMidR = params.logMidR;
+  if (params.logMidG !== undefined) flat.logMidG = params.logMidG;
+  if (params.logMidB !== undefined) flat.logMidB = params.logMidB;
+  if (params.logHighR !== undefined) flat.logHighR = params.logHighR;
+  if (params.logHighG !== undefined) flat.logHighG = params.logHighG;
+  if (params.logHighB !== undefined) flat.logHighB = params.logHighB;
+
+  // ═══════════════════════════════════════════════════════════════════════════
+  // Contrast Corrector
+  // ═══════════════════════════════════════════════════════════════════════════
+
+  if (params.contrast !== undefined) flat.contrast = params.contrast;
+  if (params.pivot !== undefined) flat.pivot = params.pivot;
+  if (params.contrastHighRange !== undefined) flat.contrastHighRange = params.contrastHighRange;
+  if (params.contrastLowRange !== undefined) flat.contrastLowRange = params.contrastLowRange;
+  if (params.softClipHigh !== undefined) flat.softClipHigh = params.softClipHigh;
+  if (params.softClipLow !== undefined) flat.softClipLow = params.softClipLow;
+
+  // ═══════════════════════════════════════════════════════════════════════════
+  // Temperature/Tint/Saturation
+  // ═══════════════════════════════════════════════════════════════════════════
+
+  if (params.temperature !== undefined) flat.temperature = params.temperature;
+  if (params.tint !== undefined) flat.tint = params.tint;
+  if (params.saturation !== undefined) flat.saturation = params.saturation;
+  if (params.colorBoost !== undefined) flat.colorBoost = params.colorBoost;
+  if (params.midtoneDetail !== undefined) flat.midtoneDetail = params.midtoneDetail;
+
+  // ═══════════════════════════════════════════════════════════════════════════
+  // HDR Zones
+  // ═══════════════════════════════════════════════════════════════════════════
+
+  if (params.hdrDark !== undefined) flat.hdrDark = params.hdrDark;
+  if (params.hdrShadow !== undefined) flat.hdrShadow = params.hdrShadow;
+  if (params.hdrLight !== undefined) flat.hdrLight = params.hdrLight;
+  if (params.hdrHighlight !== undefined) flat.hdrHighlight = params.hdrHighlight;
+  if (params.hdrGlobal !== undefined) flat.hdrGlobal = params.hdrGlobal;
+
+  return flat;
+}
+
+// ═══════════════════════════════════════════════════════════════════════════════
+// MAIN INTERFACE
+// ═══════════════════════════════════════════════════════════════════════════════
+
+/**
+ * Generate a DRX file with tool-aware parameter resolution
+ *
+ * @param {Object} options
+ * @param {Object} options.adjustments - Raw adjustments from AI or vocabulary
+ *   { contrast, exposure, temperature, saturation, tint, shadowLift, etc. }
+ * @param {Object} options.intent - Optional intent signals
+ *   { contrast: 'punchy', temperature: 'split', etc. }
+ * @param {string} options.nodeLabel - Node label for the grade
+ * @param {Object} options.userPreferences - Optional user preferences override
+ * @returns {Promise<Buffer>} DRX file buffer
+ */
+async function generateResolvedDRX(options) {
+  const {
+    adjustments = {},
+    intent = {},
+    nodeLabel = 'Color Grade',
+    userPreferences = null,
+  } = options;
+
+  // Apply user preferences if provided
+  if (userPreferences) {
+    toolResolver.setUserPreferences(userPreferences);
+  }
+
+  // Resolve tools based on adjustments and intent
+  const resolved = toolResolver.resolve({ adjustments, intent });
+
+  // Log resolution for debugging
+  console.log('[ResolvedDRX] Tool resolution:', {
+    tools: resolved.tools,
+    inputAdjustments: Object.keys(adjustments).filter(k => adjustments[k] !== undefined),
+    intent: Object.keys(intent).filter(k => intent[k] !== undefined),
+  });
+
+  // Convert to flat format for DRX generator
+  const flatParams = convertResolvedToFlat(resolved);
+
+  // Convert flat params to structured format using parseAdjustments
+  const gradeParams = drxGenerator.parseAdjustments(flatParams);
+
+  // Generate DRX using existing generator
+  const drxContent = await drxGenerator.generateDRX(gradeParams, {
+    label: nodeLabel,
+  });
+
+  // Convert string to buffer for consistency
+  const drxBuffer = Buffer.from(drxContent, 'utf8');
+
+  return {
+    buffer: drxBuffer,
+    resolved: {
+      tools: resolved.tools,
+      params: flatParams,
+      intent,
+      metadata: resolved.metadata,
+    },
+  };
+}
+
+/**
+ * Generate a DRX file from a user request string
+ * Extracts intents automatically from the request text
+ *
+ * @param {Object} options
+ * @param {string} options.request - User request string (e.g., "make it punchy and warm")
+ * @param {Object} options.adjustments - Adjustments from vocabulary/AI lookup
+ * @param {string} options.nodeLabel - Node label
+ * @param {Object} options.userPreferences - Optional user preferences
+ * @returns {Promise<Object>} { buffer, resolved }
+ */
+async function generateFromRequest(options) {
+  const {
+    request = '',
+    adjustments = {},
+    nodeLabel = 'Color Grade',
+    userPreferences = null,
+  } = options;
+
+  // Extract intents from the request string
+  const intent = vocabularyIntents.extractIntentsFromRequest(request);
+
+  console.log('[ResolvedDRX] Extracted intents from request:', {
+    request: request.substring(0, 50) + (request.length > 50 ? '...' : ''),
+    intent,
+  });
+
+  return generateResolvedDRX({
+    adjustments,
+    intent,
+    nodeLabel,
+    userPreferences,
+  });
+}
+
+/**
+ * Generate multi-node DRX with tool resolution
+ * Each node can have its own adjustments and intent
+ *
+ * @param {Object} options
+ * @param {Array} options.nodes - Array of { adjustments, intent, label }
+ * @param {Object} options.userPreferences - Optional user preferences
+ * @returns {Promise<Object>} { buffer, resolved }
+ */
+async function generateMultiNodeResolvedDRX(options) {
+  const {
+    nodes = [],
+    userPreferences = null,
+  } = options;
+
+  if (userPreferences) {
+    toolResolver.setUserPreferences(userPreferences);
+  }
+
+  // Resolve each node
+  const resolvedNodes = nodes.map((node, idx) => {
+    const resolved = toolResolver.resolve({
+      adjustments: node.adjustments || {},
+      intent: node.intent || {},
+    });
+
+    const flatParams = convertResolvedToFlat(resolved);
+
+    return {
+      label: node.label || `Node ${idx + 1}`,
+      flatParams,
+      // Convert flat params to structured format for DRX generator
+      params: drxGenerator.parseAdjustments(flatParams),
+      tools: resolved.tools,
+      intent: node.intent || {},
+    };
+  });
+
+  // Convert to format expected by generateMultiNodeDRX
+  const nodeConfigs = resolvedNodes.map(node => ({
+    label: node.label,
+    params: node.params,
+  }));
+
+  // Build default serial connections (node 1 → 2 → 3 → ...)
+  const connections = [];
+  for (let i = 0; i < nodeConfigs.length - 1; i++) {
+    connections.push({ from: i + 1, to: i + 2 });
+  }
+
+  // Generate using existing multi-node generator
+  const drxContent = await drxGenerator.generateMultiNodeDRX(nodeConfigs, connections, {
+    label: 'Multi-Node Grade',
+  });
+
+  // Convert to buffer
+  const drxBuffer = Buffer.from(drxContent, 'utf8');
+
+  return {
+    buffer: drxBuffer,
+    resolved: resolvedNodes,
+  };
+}
+
+// ═══════════════════════════════════════════════════════════════════════════════
+// UTILITY FUNCTIONS
+// ═══════════════════════════════════════════════════════════════════════════════
+
+/**
+ * Preview tool resolution without generating DRX
+ * Useful for debugging or showing users what tools will be used
+ *
+ * @param {Object} options
+ * @param {Object} options.adjustments - Raw adjustments
+ * @param {Object} options.intent - Intent signals
+ * @returns {Object} Resolution preview
+ */
+function previewResolution(options) {
+  const { adjustments = {}, intent = {} } = options;
+
+  const resolved = toolResolver.resolve({ adjustments, intent });
+
+  // Build human-readable summary
+  const summary = [];
+
+  if (resolved.tools.contrast) {
+    const tool = toolResolver.getCurrentTool('contrast') || {};
+    summary.push({
+      adjustment: 'Contrast',
+      tool: resolved.tools.contrast,
+      toolName: tool.name || resolved.tools.contrast,
+      reason: intent.contrast ? `Intent: ${intent.contrast}` : 'Default preference',
+    });
+  }
+
+  if (resolved.tools.exposure) {
+    const tool = toolResolver.getCurrentTool('exposure') || {};
+    summary.push({
+      adjustment: 'Exposure',
+      tool: resolved.tools.exposure,
+      toolName: tool.name || resolved.tools.exposure,
+      reason: intent.exposure ? `Intent: ${intent.exposure}` : 'Default preference',
+    });
+  }
+
+  if (resolved.tools.temperature) {
+    const tool = toolResolver.getCurrentTool('temperature') || {};
+    summary.push({
+      adjustment: 'Temperature',
+      tool: resolved.tools.temperature,
+      toolName: tool.name || resolved.tools.temperature,
+      reason: intent.temperature ? `Intent: ${intent.temperature}` : 'Default preference',
+    });
+  }
+
+  if (resolved.tools.saturation) {
+    const tool = toolResolver.getCurrentTool('saturation') || {};
+    summary.push({
+      adjustment: 'Saturation',
+      tool: resolved.tools.saturation,
+      toolName: tool.name || resolved.tools.saturation,
+      reason: intent.saturation ? `Intent: ${intent.saturation}` : 'Default preference',
+    });
+  }
+
+  return {
+    summary,
+    tools: resolved.tools,
+    params: resolved.params,
+    metadata: resolved.metadata,
+  };
+}
+
+/**
+ * Get available tools for an adjustment type
+ * @param {string} adjustmentType
+ * @returns {Object[]} Array of tool descriptions
+ */
+function getAvailableTools(adjustmentType) {
+  return toolResolver.getAvailableTools(adjustmentType);
+}
+
+/**
+ * Set user preferences for the resolver
+ * @param {Object} prefs
+ */
+function setUserPreferences(prefs) {
+  toolResolver.setUserPreferences(prefs);
+}
+
+/**
+ * Get current user preferences
+ * @returns {Object}
+ */
+function getUserPreferences() {
+  return toolResolver.defaultResolver.preferences;
+}
+
+// ═══════════════════════════════════════════════════════════════════════════════
+// EXPORTS
+// ═══════════════════════════════════════════════════════════════════════════════
+
+module.exports = {
+  // Main generation functions
+  generateResolvedDRX,
+  generateFromRequest,
+  generateMultiNodeResolvedDRX,
+
+  // Utilities
+  previewResolution,
+  getAvailableTools,
+  setUserPreferences,
+  getUserPreferences,
+  convertResolvedToFlat,
+
+  // Re-export tool resolver for direct access
+  toolResolver,
+
+  // Re-export vocabulary intents for direct access
+  vocabularyIntents,
+
+  // Re-export original generator for bypass cases
+  drxGenerator,
+};