vscode-behavior3 2.3.0 → 2.5.0

package/dist/extension.js

@@ -212530,6 +212530,12 @@ var Node = class _Node {
   info(msg) {
     console.info(`${this.cfg.tree.name}->${this.name}#${this.id}: ${msg}`);
   }
+  /**
+   * use console.log to print log message
+   */
+  log(msg) {
+    console.log(`${this.cfg.tree.name}->${this.name}#${this.id}: ${msg}`);
+  }
   _checkOneof(inputIndex, argValue, defaultValue) {
     const inputValue = this.input[inputIndex];
     const inputName = this.cfg.input[inputIndex];
@@ -212768,17 +212774,24 @@ var Context = class {
     return Node.create(this, treeCfg.root);
   }
 };
-var Stack = class {
+var StackSlice = class {
   _nodes = [];
-  _tree;
-  constructor(tree) {
-    this._tree = tree;
-  }
   get length() {
     return this._nodes.length;
   }
-  indexOf(node) {
-    return this._nodes.indexOf(node);
+  move(dest, start) {
+    const count = this._nodes.length - start;
+    dest._nodes.push(...this._nodes.splice(start, count));
+  }
+  clear() {
+    this._nodes.length = 0;
+  }
+};
+var Stack = class extends StackSlice {
+  _tree;
+  constructor(tree) {
+    super();
+    this._tree = tree;
   }
   top() {
     const nodes = this._nodes;
@@ -212799,9 +212812,6 @@ var Stack = class {
       this.pop();
     }
   }
-  move(dest, start, count) {
-    dest._nodes.push(...this._nodes.splice(start, count));
-  }
   clear() {
     this.popTo(0);
   }
@@ -213710,7 +213720,7 @@ var Parallel = class extends (_a17 = Node) {
       if (childStack === void 0) {
         status = children[i].tick(tree);
       } else if (childStack.length > 0) {
-        childStack.move(stack, 0, childStack.length);
+        childStack.move(stack, 0);
         while (stack.length > level) {
           status = stack.top().tick(tree);
           if (status === "running") {
@@ -213722,9 +213732,9 @@ var Parallel = class extends (_a17 = Node) {
       }
       if (status === "running") {
         if (childStack === void 0) {
-          childStack = new Stack(tree);
+          childStack = new StackSlice();
         }
-        stack.move(childStack, level, stack.length - level);
+        stack.move(childStack, level);
       } else {
         count++;
         childStack = EMPTY_STACK$1;
@@ -213770,7 +213780,7 @@ var Race = class extends (_a18 = Node) {
       if (childStack === void 0) {
         status = children[i].tick(tree);
       } else if (childStack.length > 0) {
-        childStack.move(stack, 0, childStack.length);
+        childStack.move(stack, 0);
         while (stack.length > level) {
           status = stack.top().tick(tree);
           if (status === "running") {
@@ -213780,9 +213790,9 @@ var Race = class extends (_a18 = Node) {
       }
       if (status === "running") {
         if (childStack === void 0) {
-          childStack = new Stack(tree);
+          childStack = new StackSlice();
         }
-        stack.move(childStack, level, stack.length - level);
+        stack.move(childStack, level);
       } else if (status === "success") {
         last.forEach((v) => v !== EMPTY_STACK && v.clear());
         return "success";
@@ -214018,7 +214028,7 @@ var Watchdog = class extends (_a23 = Node) {
     } else if (last === void 0) {
       status = this.children[1].tick(tree);
     } else {
-      last.move(tree.stack, 0, last.length);
+      last.move(tree.stack, 0);
       while (tree.stack.length > level) {
         const child = tree.stack.top();
         status = child.tick(tree);
@@ -214029,9 +214039,9 @@ var Watchdog = class extends (_a23 = Node) {
     }
     if (status === "running") {
       if (last === void 0) {
-        last = new Stack(tree);
+        last = new StackSlice();
       }
-      tree.stack.move(last, level, tree.stack.length - level);
+      tree.stack.move(last, level);
       return tree.yield(this, last);
     } else {
       return status;
@@ -214857,7 +214867,7 @@ var Timeout = class extends (_a41 = Node) {
       last.stack.clear();
       return "failure";
     } else {
-      last.stack.move(stack, 0, last.stack.length);
+      last.stack.move(stack, 0);
       while (stack.length > level) {
         const child = stack.top();
         status = child.tick(tree);
@@ -214870,11 +214880,11 @@ var Timeout = class extends (_a41 = Node) {
       if (last === void 0) {
         const time = this._checkOneof(0, this.args.time, 0);
         last = {
-          stack: new Stack(tree),
+          stack: new StackSlice(),
           expired: context.time + time
         };
       }
-      stack.move(last.stack, level, stack.length - level);
+      stack.move(last.stack, level);
       return tree.yield(this, last);
     } else {
       return status;
@@ -214897,6 +214907,7 @@ var Timeout = class extends (_a41 = Node) {
         }
       ],
       doc: `
+                + \u5728\u9650\u5B9A\u65F6\u95F4\u5185\u6267\u884C\u5B50\u8282\u70B9\uFF0C\u8D85\u65F6\u5219\u5931\u8D25
                 + \u53EA\u80FD\u6709\u4E00\u4E2A\u5B50\u8282\u70B9\uFF0C\u591A\u4E2A\u4EC5\u6267\u884C\u7B2C\u4E00\u4E2A
                 + \u5F53\u5B50\u8282\u70B9\u6267\u884C\u8D85\u65F6\u6216\u8FD4\u56DE \`failure\` \u65F6\uFF0C\u8FD4\u56DE \`failure\`
                 + \u5176\u4F59\u60C5\u51B5\u8FD4\u56DE\u5B50\u8282\u70B9\u7684\u6267\u884C\u72B6\u6001
@@ -215264,10 +215275,7 @@ function customAlphabet(alphabet, size = 21) {
 
 // webview/shared/stable-id.ts
 var UUID_ALPHABET = "0123456789abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ";
-var generateUuid = customAlphabet(
-  UUID_ALPHABET,
-  10
-);
+var generateUuid = customAlphabet(UUID_ALPHABET, 10);
 var hashString = (value) => {
   let hash = 2166136261;
   for (let index = 0; index < value.length; index += 1) {
@@ -215281,7 +215289,7 @@ var generateDeterministicUuid = (seed) => {
   let result = "";
   for (let index = 0; index < 10; index += 1) {
     state = Math.imul(state ^ state >>> 16, 2246822519) >>> 0;
-    state ^= hashString(`${seed}:${index}`);
+    state = (state ^ hashString(`${seed}:${index}`)) >>> 0;
     result += UUID_ALPHABET[state % UUID_ALPHABET.length];
   }
   return result;
@@ -215375,6 +215383,12 @@ var asRequiredString = (value, label) => {
   }
   return value;
 };
+var normalizeTreeVersion = (value) => {
+  if (value === void 0) {
+    return DOCUMENT_VERSION;
+  }
+  return asRequiredString(value, "tree file version");
+};
 var asStringArray = (value, label) => {
   if (value === void 0) {
     return [];
@@ -215389,6 +215403,34 @@ var asStringArray = (value, label) => {
     return entry;
   });
 };
+var normalizeNodeLabel = (label, record) => {
+  const rawNodeName = record.name;
+  if (typeof rawNodeName !== "string" || !rawNodeName.trim()) {
+    return label;
+  }
+  return `${label}(${rawNodeName.trim()})`;
+};
+var normalizeNodeSlotEntry = (value, label) => {
+  if (typeof value === "string") {
+    return asRequiredString(value, label);
+  }
+  const record = expectPlainRecord(value, label);
+  return {
+    name: asRequiredString(record.name, `${label}.name`),
+    checker: asOptionalNonEmptyString(record.checker, `${label}.checker`),
+    visible: asOptionalNonEmptyString(record.visible, `${label}.visible`)
+  };
+};
+var normalizeNodeSlots = (value, label) => {
+  if (value === void 0) {
+    return void 0;
+  }
+  if (!Array.isArray(value)) {
+    throw new Error(`${label} must be an array`);
+  }
+  const slots = value.map((entry, index) => normalizeNodeSlotEntry(entry, `${label}[${index}]`));
+  return slots.length > 0 ? slots : void 0;
+};
 var asWorkdirRelativeJsonPathArray = (value, label) => {
   const entries = asStringArray(value, label);
   return entries.map((entry, index) => {
@@ -215499,44 +215541,43 @@ var normalizeNodeArgs = (value, label) => {
       oneof: asOptionalString(record.oneof),
       default: record.default,
       options: normalizeNodeArgOptions(record.options, `${label}[${index}].options`),
-      checker: asOptionalNonEmptyString(record.checker, `${label}[${index}].checker`)
+      checker: asOptionalNonEmptyString(record.checker, `${label}[${index}].checker`),
+      visible: asOptionalNonEmptyString(record.visible, `${label}[${index}].visible`)
     };
   });
 };
 var normalizeNodeDef = (value, label) => {
   const record = expectPlainRecord(value, label);
-  const type = asRequiredString(record.type, `${label}.type`);
+  const nodeLabel = normalizeNodeLabel(label, record);
+  const name = asRequiredString(record.name, `${nodeLabel}.name`);
+  const type = asRequiredString(record.type, `${nodeLabel}.type`);
   if (!NODE_DEF_TYPES.has(type)) {
-    throw new Error(`${label}.type must be one of ${Array.from(NODE_DEF_TYPES).join(", ")}`);
+    throw new Error(
+      `${nodeLabel}.type must be one of ${Array.from(NODE_DEF_TYPES).join(", ")}`
+    );
   }
   const groupValue = record.group;
   const group = groupValue === void 0 ? void 0 : Array.isArray(groupValue) ? groupValue.map(
-    (entry, index) => asRequiredString(entry, `${label}.group[${index}]`)
-  ) : [asRequiredString(groupValue, `${label}.group`)];
+    (entry, index) => asRequiredString(entry, `${nodeLabel}.group[${index}]`)
+  ) : [asRequiredString(groupValue, `${nodeLabel}.group`)];
   const childrenValue = record.children;
   if (childrenValue !== void 0 && !CHILDREN_ARITIES.has(childrenValue)) {
-    throw new Error(`${label}.children must be one of -1, 0, 1, 2, 3`);
+    throw new Error(`${nodeLabel}.children must be one of -1, 0, 1, 2, 3`);
   }
   const statusValue = record.status;
-  const status = statusValue === void 0 ? void 0 : asStringArray(statusValue, `${label}.status`).map((entry) => {
+  const status = statusValue === void 0 ? void 0 : asStringArray(statusValue, `${nodeLabel}.status`).map((entry) => {
     if (!NODE_STATUS_VALUES.has(entry)) {
-      throw new Error(`${label}.status contains unsupported value: ${entry}`);
+      throw new Error(`${nodeLabel}.status contains unsupported value: ${entry}`);
     }
     return entry;
   });
   return {
-    name: asRequiredString(record.name, `${label}.name`),
+    name,
     type,
     desc: asOptionalString(record.desc) ?? "",
-    input: (() => {
-      const input = asStringArray(record.input, `${label}.input`);
-      return input.length > 0 ? input : void 0;
-    })(),
-    output: (() => {
-      const output = asStringArray(record.output, `${label}.output`);
-      return output.length > 0 ? output : void 0;
-    })(),
-    args: normalizeNodeArgs(record.args, `${label}.args`),
+    input: normalizeNodeSlots(record.input, `${nodeLabel}.input`),
+    output: normalizeNodeSlots(record.output, `${nodeLabel}.output`),
+    args: normalizeNodeArgs(record.args, `${nodeLabel}.args`),
     doc: asOptionalString(record.doc),
     icon: asOptionalString(record.icon),
     color: asOptionalString(record.color),
@@ -215693,7 +215734,7 @@ var normalizeTreeData = (value, opts) => {
   const variablesValue = record.variables;
   const variablesRecord = variablesValue === void 0 ? void 0 : expectPlainRecord(variablesValue, "tree file variables");
   return {
-    version: asRequiredString(record.version, "tree file version"),
+    version: normalizeTreeVersion(record.version),
     name: asRequiredString(record.name, "tree file name"),
     prefix: asOptionalString(record.prefix) ?? "",
     desc: asOptionalString(record.desc),
@@ -215948,10 +215989,10 @@ var applyMainTreeDisplayIds = (root, idsByStableId) => {
     }
   });
 };
-var hasMissingStableIds = (content) => {
+var needsLegacyTreeWriteback = (content) => {
   try {
     const parsed = JSON.parse(content);
-    return subtreeNeedsMissingIds(parsed.root) || parsed.$override !== void 0 || parsed.import !== void 0 || parsed.vars !== void 0;
+    return parsed.version === void 0 || subtreeNeedsMissingIds(parsed.root) || parsed.$override !== void 0 || parsed.import !== void 0 || parsed.vars !== void 0;
   } catch {
     return false;
   }
@@ -215974,7 +216015,7 @@ var loadSubtreeSourceCache = async (params) => {
       return;
     }
     try {
-      const needsWriteback = hasMissingStableIds(content);
+      const needsWriteback = needsLegacyTreeWriteback(content);
       const tree = parsePersistedTreeContent(content, normalizedPath);
       cache[normalizedPath] = tree;
       await params.onTreeLoaded?.({
@@ -216143,16 +216184,22 @@ var findNodeDef = (nodeDefMap, nodeName) => {
   return nodeDefMap.get(nodeName) ?? null;
 };
 var cleanSlotLabel = (value) => value.replace(/\.\.\.$/, "").replace(/\?/g, "");
+var isStructuredSlotDefinition = (slot) => Boolean(slot && typeof slot === "object" && !Array.isArray(slot));
 var parseSlotDefinition = (slot, slotDefs, index) => {
-  const raw = slot ?? "";
+  const raw = typeof slot === "string" ? slot : slot?.name ?? "";
   const hasOptionalMarker = raw.includes("?");
   const hasVariadicMarker = raw.endsWith("...");
   const variadic = hasVariadicMarker && (slotDefs && index !== void 0 ? index === slotDefs.length - 1 : true);
+  const checker = isStructuredSlotDefinition(slot) ? slot.checker?.trim() || void 0 : void 0;
+  const visible = isStructuredSlotDefinition(slot) ? slot.visible?.trim() || void 0 : void 0;
   return {
     raw,
+    name: cleanSlotLabel(raw),
     label: cleanSlotLabel(raw),
     required: !hasOptionalMarker,
-    variadic
+    variadic,
+    checker,
+    visible
   };
 };
 var getNodeArgRawType = (arg) => {
@@ -216475,6 +216522,8 @@ var BUILD_HOOK_MARKER = "__behavior3BuildHook";
 var BATCH_HOOK_MARKER = "__behavior3BatchHook";
 var CHECK_HOOK_MARKER = "__behavior3CheckHook";
 var CHECK_HOOK_NAME = "__behavior3CheckName";
+var VISIBLE_HOOK_MARKER = "__behavior3VisibleHook";
+var VISIBLE_HOOK_NAME = "__behavior3VisibleName";
 var markBuildHook = (ctor) => {
   Object.defineProperty(ctor, BUILD_HOOK_MARKER, {
     value: true,
@@ -216501,15 +216550,34 @@ var markCheckCtor = (ctor, explicitName) => {
   });
   return ctor;
 };
+var markVisibleCtor = (ctor, explicitName) => {
+  const name = explicitName?.trim() || ctor.name;
+  Object.defineProperty(ctor, VISIBLE_HOOK_MARKER, {
+    value: true,
+    configurable: false
+  });
+  Object.defineProperty(ctor, VISIBLE_HOOK_NAME, {
+    value: name,
+    configurable: false
+  });
+  return ctor;
+};
 var markCheckHook = (nameOrCtor, _context) => {
   if (typeof nameOrCtor === "function") {
     return markCheckCtor(nameOrCtor);
   }
   return (ctor) => markCheckCtor(ctor, nameOrCtor);
 };
+var markVisibleHook = (nameOrCtor, _context) => {
+  if (typeof nameOrCtor === "function") {
+    return markVisibleCtor(nameOrCtor);
+  }
+  return (ctor) => markVisibleCtor(ctor, nameOrCtor);
+};
 var isDecoratedBuildHookCtor = (value) => typeof value === "function" && value[BUILD_HOOK_MARKER] === true;
 var isDecoratedBatchHookCtor = (value) => typeof value === "function" && value[BATCH_HOOK_MARKER] === true;
 var isDecoratedCheckCtor = (value) => typeof value === "function" && value[CHECK_HOOK_MARKER] === true;
+var isDecoratedVisibleCtor = (value) => typeof value === "function" && value[VISIBLE_HOOK_MARKER] === true;
 var findDecoratedBuildHookCtor = (moduleRecord) => {
   const decorated = Array.from(new Set(Object.values(moduleRecord))).filter(
     isDecoratedBuildHookCtor
@@ -216541,6 +216609,7 @@ var findDecoratedBatchHookCtor = (moduleRecord) => {
   return legacyDecorated[0];
 };
 var findDecoratedCheckCtors = (moduleRecord) => Array.from(new Set(Object.values(moduleRecord))).filter(isDecoratedCheckCtor);
+var findDecoratedVisibleCtors = (moduleRecord) => Array.from(new Set(Object.values(moduleRecord))).filter(isDecoratedVisibleCtor);
 var createBuildHooks = (moduleExports, env2, reportMissing = true) => {
   if (!moduleExports || typeof moduleExports !== "object") {
     return void 0;
@@ -216591,7 +216660,7 @@ var createBatchHooks = (moduleExports, env2, reportMissing = true) => {
   }
   return void 0;
 };
-var createNodeArgCheckers = (moduleExports, env2) => {
+var createNodeFieldCheckers = (moduleExports, env2) => {
   const checkers = /* @__PURE__ */ new Map();
   let hasError = false;
   if (!moduleExports || typeof moduleExports !== "object") {
@@ -216626,10 +216695,70 @@ var createNodeArgCheckers = (moduleExports, env2) => {
   }
   return { checkers, hasError, hasCheckers: decorated.length > 0 };
 };
+var normalizeNodeFieldVisibleResult = (result) => result !== false;
+var createNodeFieldVisibles = (moduleExports, env2) => {
+  const visibles = /* @__PURE__ */ new Map();
+  let hasError = false;
+  if (!moduleExports || typeof moduleExports !== "object") {
+    return { visibles, hasError, hasVisibles: false };
+  }
+  const moduleRecord = moduleExports;
+  const decorated = findDecoratedVisibleCtors(moduleRecord);
+  for (const ctor of decorated) {
+    const name = ctor[VISIBLE_HOOK_NAME]?.trim() || ctor.name;
+    if (!name) {
+      logger.error("visible class must have a non-empty @behavior3.visible name");
+      hasError = true;
+      continue;
+    }
+    if (visibles.has(name)) {
+      logger.error(`duplicate @behavior3.visible registration: ${name}`);
+      hasError = true;
+      continue;
+    }
+    try {
+      const instance = new ctor(env2);
+      if (typeof instance.visible !== "function") {
+        logger.error(`visible '${name}' must provide a visible(value, ctx) method`);
+        hasError = true;
+        continue;
+      }
+      visibles.set(name, instance);
+    } catch (error) {
+      logger.error(`failed to instantiate visible '${name}'`, error);
+      hasError = true;
+    }
+  }
+  return { visibles, hasError, hasVisibles: decorated.length > 0 };
+};
+var createNodeFieldVisibleRuntimeWithCheckModules = (buildScriptModule, checkScriptModules, env2) => {
+  const nodeFieldVisibles = /* @__PURE__ */ new Map();
+  let hasError = false;
+  const mergeModuleVisibles = (moduleExports) => {
+    const visibleResult = createNodeFieldVisibles(moduleExports, env2);
+    hasError = hasError || visibleResult.hasError;
+    for (const [name, visible] of visibleResult.visibles) {
+      if (nodeFieldVisibles.has(name)) {
+        logger.error(`duplicate @behavior3.visible registration: ${name}`);
+        hasError = true;
+        continue;
+      }
+      nodeFieldVisibles.set(name, visible);
+    }
+  };
+  mergeModuleVisibles(buildScriptModule);
+  for (const checkScript of checkScriptModules) {
+    mergeModuleVisibles(checkScript.moduleExports);
+  }
+  return {
+    nodeFieldVisibles,
+    hasError
+  };
+};
 var createBuildScriptRuntime = (moduleExports, env2) => {
   if (!moduleExports || typeof moduleExports !== "object") {
     return {
-      nodeArgCheckers: /* @__PURE__ */ new Map(),
+      nodeFieldCheckers: /* @__PURE__ */ new Map(),
       hasError: false,
       hasEntries: false
     };
@@ -216637,7 +216766,7 @@ var createBuildScriptRuntime = (moduleExports, env2) => {
   const moduleRecord = moduleExports;
   const hasBuildHookCandidate = typeof moduleRecord.BuildHook === "function" || typeof moduleRecord.Hook === "function" || Object.values(moduleRecord).some(isDecoratedBuildHookCtor) || typeof moduleRecord.default === "function" && !isDecoratedCheckCtor(moduleRecord.default) && !isDecoratedBatchHookCtor(moduleRecord.default);
   const buildScript = createBuildHooks(moduleExports, env2, false);
-  const checkerResult = createNodeArgCheckers(moduleExports, env2);
+  const checkerResult = createNodeFieldCheckers(moduleExports, env2);
   const hasEntries = Boolean(buildScript) || checkerResult.hasCheckers;
   if (!hasEntries) {
     logger.error(
@@ -216646,39 +216775,35 @@ var createBuildScriptRuntime = (moduleExports, env2) => {
   }
   return {
     buildScript,
-    nodeArgCheckers: checkerResult.checkers,
+    nodeFieldCheckers: checkerResult.checkers,
     hasError: checkerResult.hasError || !hasEntries || hasBuildHookCandidate && !buildScript,
     hasEntries
   };
 };
 var createBuildScriptRuntimeWithCheckModules = (buildScriptModule, checkScriptModules, env2) => {
   const runtime = createBuildScriptRuntime(buildScriptModule, env2);
-  const nodeArgCheckers = new Map(runtime.nodeArgCheckers);
+  const nodeFieldCheckers = new Map(runtime.nodeFieldCheckers);
   let hasError = runtime.hasError;
   let hasCheckEntries = false;
   for (const checkScript of checkScriptModules) {
-    const checkerResult = createNodeArgCheckers(checkScript.moduleExports, env2);
+    const checkerResult = createNodeFieldCheckers(checkScript.moduleExports, env2);
     if (!checkerResult.hasCheckers) {
-      logger.error(
-        `check script must export at least one @behavior3.check class: ${checkScript.path}`
-      );
-      hasError = true;
       continue;
     }
     hasCheckEntries = true;
     hasError = hasError || checkerResult.hasError;
     for (const [name, checker] of checkerResult.checkers) {
-      if (nodeArgCheckers.has(name)) {
+      if (nodeFieldCheckers.has(name)) {
         logger.error(`duplicate @behavior3.check registration: ${name}`);
         hasError = true;
         continue;
       }
-      nodeArgCheckers.set(name, checker);
+      nodeFieldCheckers.set(name, checker);
     }
   }
   return {
     ...runtime,
-    nodeArgCheckers,
+    nodeFieldCheckers,
     hasError,
     hasEntries: runtime.hasEntries || hasCheckEntries
   };
@@ -216824,7 +216949,12 @@ var processBatchTree = (tree, treePath, batch, errors) => {
   }
   return tree;
 };
-var normalizeNodeArgCheckResult = (result) => {
+var createEmptyNodeFieldVisibilityState = () => ({
+  args: {},
+  input: {},
+  output: {}
+});
+var normalizeNodeFieldCheckResult = (result) => {
   if (Array.isArray(result)) {
     return result.filter((entry) => typeof entry === "string" && entry.trim());
   }
@@ -216842,7 +216972,105 @@ var walkTreeNodes = (node, visit) => {
     walkTreeNodes(child, visit);
   }
 };
-var collectNodeArgCheckDiagnostics = (params) => {
+var buildNodeSlotField = (slot, slotDefs, index) => {
+  const parsed = parseSlotDefinition(slot, slotDefs, index);
+  return {
+    name: parsed.name,
+    label: parsed.label,
+    required: parsed.required,
+    variadic: parsed.variadic,
+    checker: parsed.checker,
+    visible: parsed.visible
+  };
+};
+var getSlotValue = (values, slotDefs, index) => {
+  const slotField = parseSlotDefinition(slotDefs?.[index] ?? "", slotDefs, index);
+  return slotField.variadic ? values?.slice(index) ?? [] : values?.[index];
+};
+var formatFieldLocator = (node, fieldKind, fieldName, fieldIndex) => {
+  if (fieldKind === "arg") {
+    return `${node.id}|${node.name}.${fieldName}`;
+  }
+  return `${node.id}|${node.name}.${fieldKind}[${fieldIndex ?? 0}:${fieldName}]`;
+};
+var getNodeSlotContext = (params) => {
+  if (!isStructuredSlotDefinition(params.slot)) {
+    return null;
+  }
+  return {
+    node: params.node,
+    tree: params.tree,
+    nodeDef: params.nodeDef,
+    fieldKind: params.fieldKind,
+    fieldName: buildNodeSlotField(params.slot, params.slotDefs, params.index).name,
+    fieldIndex: params.index,
+    slot: params.fieldKind === "input" ? params.slot : params.slot,
+    slotField: buildNodeSlotField(params.slot, params.slotDefs, params.index),
+    treePath: params.treePath,
+    env: params.env
+  };
+};
+var visitCustomNodeFields = (params) => {
+  for (const arg of params.nodeDef.args ?? []) {
+    const checkerName = arg.checker?.trim() || void 0;
+    const visibleName = arg.visible?.trim() || void 0;
+    if (!(checkerName || visibleName)) {
+      continue;
+    }
+    const ctx = {
+      node: params.node,
+      tree: params.tree,
+      nodeDef: params.nodeDef,
+      fieldKind: "arg",
+      fieldName: arg.name,
+      arg,
+      treePath: params.treePath,
+      env: params.env
+    };
+    params.onArg?.({
+      fieldName: arg.name,
+      checkerName,
+      visibleName,
+      value: params.node.args?.[arg.name],
+      ctx
+    });
+  }
+  for (const [fieldKind, slotDefs, values, visitor] of [
+    ["input", params.nodeDef.input, params.node.input, params.onInput],
+    ["output", params.nodeDef.output, params.node.output, params.onOutput]
+  ]) {
+    for (let index = 0; index < (slotDefs?.length ?? 0); index += 1) {
+      const slot = slotDefs?.[index] ?? "";
+      const slotField = buildNodeSlotField(slot, slotDefs, index);
+      if (!(slotField.checker || slotField.visible)) {
+        continue;
+      }
+      const ctx = getNodeSlotContext({
+        fieldKind,
+        node: params.node,
+        tree: params.tree,
+        nodeDef: params.nodeDef,
+        slotDefs,
+        slot,
+        index,
+        treePath: params.treePath,
+        env: params.env
+      });
+      if (!ctx) {
+        continue;
+      }
+      visitor?.({
+        fieldName: slotField.name,
+        fieldIndex: index,
+        checkerName: slotField.checker,
+        visibleName: slotField.visible,
+        value: getSlotValue(values, slotDefs, index),
+        ctx
+      });
+    }
+  }
+};
+var collectNodeFieldCheckDiagnostics = (params) => {
   const diagnostics = [];
   const targets = params.targets ?? [];
   const entries = targets.length ? targets : (() => {
@@ -216856,47 +217084,182 @@ var collectNodeArgCheckDiagnostics = (params) => {
     if (!nodeDef) {
       continue;
     }
-    for (const arg of nodeDef.args ?? []) {
-      const checkerName = arg.checker?.trim();
-      if (!checkerName) {
-        continue;
+    visitCustomNodeFields({
+      node,
+      tree: params.tree,
+      nodeDef,
+      treePath: target.treePath ?? params.treePath,
+      env: params.env,
+      onArg: ({ fieldName, checkerName, value, ctx }) => {
+        if (!checkerName) {
+          return;
+        }
+        const pushDiagnostic = (message) => {
+          diagnostics.push({
+            instanceKey: target.instanceKey,
+            nodeId: node.id,
+            nodeName: node.name,
+            fieldKind: "arg",
+            fieldName,
+            checker: checkerName,
+            message
+          });
+        };
+        const checker = params.checkers.get(checkerName);
+        if (!checker) {
+          pushDiagnostic(`checker '${checkerName}' is not registered`);
+          return;
+        }
+        try {
+          const messages = normalizeNodeFieldCheckResult(checker.validate(value, ctx));
+          messages.forEach(pushDiagnostic);
+        } catch (error) {
+          pushDiagnostic(`checker '${checkerName}' failed: ${formatRuntimeError(error)}`);
+        }
+      },
+      onInput: ({ fieldName, fieldIndex, checkerName, value, ctx }) => {
+        if (!checkerName) {
+          return;
+        }
+        const pushDiagnostic = (message) => {
+          diagnostics.push({
+            instanceKey: target.instanceKey,
+            nodeId: node.id,
+            nodeName: node.name,
+            fieldKind: "input",
+            fieldName,
+            fieldIndex,
+            checker: checkerName,
+            message
+          });
+        };
+        const checker = params.checkers.get(checkerName);
+        if (!checker) {
+          pushDiagnostic(`checker '${checkerName}' is not registered`);
+          return;
+        }
+        try {
+          const messages = normalizeNodeFieldCheckResult(checker.validate(value, ctx));
+          messages.forEach(pushDiagnostic);
+        } catch (error) {
+          pushDiagnostic(`checker '${checkerName}' failed: ${formatRuntimeError(error)}`);
+        }
+      },
+      onOutput: ({ fieldName, fieldIndex, checkerName, value, ctx }) => {
+        if (!checkerName) {
+          return;
+        }
+        const pushDiagnostic = (message) => {
+          diagnostics.push({
+            instanceKey: target.instanceKey,
+            nodeId: node.id,
+            nodeName: node.name,
+            fieldKind: "output",
+            fieldName,
+            fieldIndex,
+            checker: checkerName,
+            message
+          });
+        };
+        const checker = params.checkers.get(checkerName);
+        if (!checker) {
+          pushDiagnostic(`checker '${checkerName}' is not registered`);
+          return;
+        }
+        try {
+          const messages = normalizeNodeFieldCheckResult(checker.validate(value, ctx));
+          messages.forEach(pushDiagnostic);
+        } catch (error) {
+          pushDiagnostic(`checker '${checkerName}' failed: ${formatRuntimeError(error)}`);
+        }
       }
-      const pushDiagnostic = (message) => {
-        diagnostics.push({
-          instanceKey: target.instanceKey,
-          nodeId: node.id,
-          nodeName: node.name,
-          argName: arg.name,
-          checker: checkerName,
-          message
-        });
-      };
-      const checker = params.checkers.get(checkerName);
-      if (!checker) {
-        pushDiagnostic(`checker '${checkerName}' is not registered`);
-        continue;
+    });
+  }
+  return diagnostics;
+};
+var resolveNodeFieldVisibility = (params) => {
+  const visibility = createEmptyNodeFieldVisibilityState();
+  const node = params.target;
+  const nodeDef = params.env.nodeDefs.get(node.name);
+  if (!nodeDef) {
+    return visibility;
+  }
+  visitCustomNodeFields({
+    node,
+    tree: params.tree,
+    nodeDef,
+    treePath: params.targetTreePath ?? params.treePath,
+    env: params.env,
+    onArg: ({ fieldName, visibleName, value, ctx }) => {
+      if (!visibleName) {
+        return;
+      }
+      const visible = params.visibles.get(visibleName);
+      if (!visible) {
+        params.env.logger.warn(
+          `visible '${visibleName}' is not registered for ${formatFieldLocator(node, "arg", fieldName)}`
+        );
+        return;
       }
       try {
-        const messages = normalizeNodeArgCheckResult(
-          checker.validate(node.args?.[arg.name], {
-            node,
-            tree: params.tree,
-            nodeDef,
-            arg,
-            argName: arg.name,
-            treePath: target.treePath ?? params.treePath,
-            env: params.env
-          })
+        visibility.args[fieldName] = normalizeNodeFieldVisibleResult(
+          visible.visible(value, ctx)
+        );
+      } catch (error) {
+        params.env.logger.warn(
+          `visible '${visibleName}' failed for ${formatFieldLocator(node, "arg", fieldName)}: ${formatRuntimeError(error)}`
+        );
+        visibility.args[fieldName] = true;
+      }
+    },
+    onInput: ({ fieldName, fieldIndex, visibleName, value, ctx }) => {
+      if (!visibleName) {
+        return;
+      }
+      const visible = params.visibles.get(visibleName);
+      if (!visible) {
+        params.env.logger.warn(
+          `visible '${visibleName}' is not registered for ${formatFieldLocator(node, "input", fieldName, fieldIndex)}`
+        );
+        return;
+      }
+      try {
+        visibility.input[fieldIndex] = normalizeNodeFieldVisibleResult(
+          visible.visible(value, ctx)
         );
-        messages.forEach(pushDiagnostic);
       } catch (error) {
-        pushDiagnostic(`checker '${checkerName}' failed: ${formatRuntimeError(error)}`);
+        params.env.logger.warn(
+          `visible '${visibleName}' failed for ${formatFieldLocator(node, "input", fieldName, fieldIndex)}: ${formatRuntimeError(error)}`
+        );
+        visibility.input[fieldIndex] = true;
+      }
+    },
+    onOutput: ({ fieldName, fieldIndex, visibleName, value, ctx }) => {
+      if (!visibleName) {
+        return;
+      }
+      const visible = params.visibles.get(visibleName);
+      if (!visible) {
+        params.env.logger.warn(
+          `visible '${visibleName}' is not registered for ${formatFieldLocator(node, "output", fieldName, fieldIndex)}`
+        );
+        return;
+      }
+      try {
+        visibility.output[fieldIndex] = normalizeNodeFieldVisibleResult(
+          visible.visible(value, ctx)
+        );
+      } catch (error) {
+        params.env.logger.warn(
+          `visible '${visibleName}' failed for ${formatFieldLocator(node, "output", fieldName, fieldIndex)}: ${formatRuntimeError(error)}`
+        );
+        visibility.output[fieldIndex] = true;
       }
     }
-  }
-  return diagnostics;
+  });
+  return visibility;
 };
-var formatNodeArgCheckBuildDiagnostic = (diagnostic) => `check ${diagnostic.nodeId}|${diagnostic.nodeName}: ${diagnostic.argName}: ${diagnostic.message}`;
+var formatNodeFieldCheckBuildDiagnostic = (diagnostic) => diagnostic.fieldKind === "arg" ? `check ${diagnostic.nodeId}|${diagnostic.nodeName}: ${diagnostic.fieldName}: ${diagnostic.message}` : `check ${diagnostic.nodeId}|${diagnostic.nodeName}: ${diagnostic.fieldKind}[${diagnostic.fieldIndex ?? 0}:${diagnostic.fieldName}]: ${diagnostic.message}`;
 var syncFilesFromDiskWithContext = (files, parsedVarDecl, workdir) => {
   if (!hasFs()) {
     return;
@@ -217063,7 +217426,8 @@ var applyBehavior3DecoratorGlobal = () => {
     ...decoratorGlobalState.previousBehavior3 && typeof decoratorGlobalState.previousBehavior3 === "object" ? decoratorGlobalState.previousBehavior3 : {},
     build: markBuildHook,
     batch: markBatchHook,
-    check: markCheckHook
+    check: markCheckHook,
+    visible: markVisibleHook
   };
 };
 var restoreBehavior3DecoratorGlobal = () => {
@@ -217373,16 +217737,16 @@ var buildProjectWithContext = async (project, buildDir, context) => {
     if (!context.checkNodeData(tree.root, (message) => errors.push(message))) {
       hasError = true;
     }
-    const checkDiagnostics = collectNodeArgCheckDiagnostics({
+    const checkDiagnostics = collectNodeFieldCheckDiagnostics({
       tree,
       treePath: candidatePath,
       env: scriptEnv,
-      checkers: buildRuntime.nodeArgCheckers
+      checkers: buildRuntime.nodeFieldCheckers
     });
     if (checkDiagnostics.length) {
       hasError = true;
       checkDiagnostics.forEach(
-        (diagnostic) => errors.push(formatNodeArgCheckBuildDiagnostic(diagnostic))
+        (diagnostic) => errors.push(formatNodeFieldCheckBuildDiagnostic(diagnostic))
       );
     }
     if (errors.length) {
@@ -217564,6 +217928,14 @@ var validateExpressionEntries = (entries, usingVars, checkExpr) => {
   return null;
 };
 var getArgLabel = (arg) => arg.desc || arg.name;
+var findNodeArgOneofInputIndex = (arg, inputDefs) => {
+  if (!arg.oneof || !inputDefs?.length) {
+    return -1;
+  }
+  return inputDefs.findIndex(
+    (input, index) => parseSlotDefinition(input, inputDefs, index).label === arg.oneof
+  );
+};
 var isRequiredNodeArgValueMissing = (arg, value) => {
   if (isNodeArgOptional(arg)) {
     return false;
@@ -217678,6 +218050,28 @@ var validateNodeArgValue = (params) => {
   }
   return validateNodeArgScalarValue(arg, value, args, validateOptions);
 };
+var validateNodeArgOneof = (params) => {
+  const { arg, argValue, inputValues, inputDefs } = params;
+  if (!arg.oneof) {
+    return null;
+  }
+  const relatedInputIndex = findNodeArgOneofInputIndex(arg, inputDefs);
+  if (relatedInputIndex < 0) {
+    return {
+      code: "missing-oneof-input",
+      argName: arg.name,
+      inputLabel: arg.oneof
+    };
+  }
+  if (checkOneof(arg, argValue, inputValues?.[relatedInputIndex])) {
+    return null;
+  }
+  return {
+    code: "oneof-conflict",
+    argName: arg.name,
+    inputLabel: arg.oneof
+  };
+};
 
 // webview/shared/b3build-context.ts
 var unknownNodeDef = {
@@ -217761,6 +218155,10 @@ var formatBuildDiagnostic = (diagnostic) => {
       return `intput field '${diagnostic.label}' is required`;
     case "required-output":
       return `output field '${diagnostic.label}' is required`;
+    case "missing-oneof-input":
+      return `missing oneof input slot '${diagnostic.inputLabel}' for arg '${diagnostic.argName}'`;
+    case "oneof-conflict":
+      return `only one of arg '${diagnostic.argName}' and input '${diagnostic.inputLabel}' can be set`;
     case "invalid-arg-value": {
       const value = JSON.stringify(diagnostic.value);
       switch (diagnostic.expected) {
@@ -217801,14 +218199,15 @@ var checkNodeArg = (data, conf, i, printer) => {
   const diagnostics = validateNodeArgValue({ arg, value, args: data.args ?? {} });
   let hasError = diagnostics.length > 0;
   diagnostics.forEach((diagnostic) => error(formatBuildDiagnostic(diagnostic)));
-  if (arg.oneof !== void 0) {
-    const idx = conf.input?.findIndex((v) => v.startsWith(arg.oneof)) ?? -1;
-    if (!checkOneof(arg, data.args?.[arg.name], data.input?.[idx])) {
-      error(
-        `only one is allowed for between argument '${arg.name}' and input '${data.input?.[idx]}'`
-      );
-      hasError = true;
-    }
+  const oneofDiagnostic = validateNodeArgOneof({
+    arg,
+    argValue: value,
+    inputValues: data.input,
+    inputDefs: conf.input
+  });
+  if (oneofDiagnostic) {
+    error(formatBuildDiagnostic(oneofDiagnostic));
+    hasError = true;
   }
   return !hasError;
 };
@@ -217880,6 +218279,7 @@ var checkNodeDataWithState = (data, printer, state) => {
   let hasVaridicInput = false;
   if (conf.input) {
     for (let i = 0; i < conf.input.length; i++) {
+      const slotDefinition = parseSlotDefinition(conf.input[i] ?? "", conf.input, i);
       if (!data.input) {
         data.input = [];
       }
@@ -217887,7 +218287,7 @@ var checkNodeDataWithState = (data, printer, state) => {
         data.input[i] = "";
       }
       if (!isValidInputOrOutput(conf.input, data.input, i)) {
-        error(`intput field '${conf.input[i]}' is required`);
+        error(`intput field '${slotDefinition.label}' is required`);
         hasError = true;
       }
       if (i === conf.input.length - 1 && isVariadic(conf.input, -1)) {
@@ -217901,6 +218301,7 @@ var checkNodeDataWithState = (data, printer, state) => {
   let hasVaridicOutput = false;
   if (conf.output) {
     for (let i = 0; i < conf.output.length; i++) {
+      const slotDefinition = parseSlotDefinition(conf.output[i] ?? "", conf.output, i);
       if (!data.output) {
         data.output = [];
       }
@@ -217908,7 +218309,7 @@ var checkNodeDataWithState = (data, printer, state) => {
         data.output[i] = "";
       }
       if (!isValidInputOrOutput(conf.output, data.output, i)) {
-        error(`output field '${conf.output[i]}' is required`);
+        error(`output field '${slotDefinition.label}' is required`);
         hasError = true;
       }
       if (i === conf.output.length - 1 && isVariadic(conf.output, -1)) {
@@ -220548,6 +220949,37 @@ var computeNodeOverride = (original, edited, def) => {
   }
   return hasDiff ? diff : null;
 };
+var pruneNodeArgsByDefinition = (args, nodeDef) => {
+  if (!args || !nodeDef) {
+    return args;
+  }
+  const argDefs = nodeDef.args ?? [];
+  if (argDefs.length === 0) {
+    return void 0;
+  }
+  const declaredNames = new Set(argDefs.map((arg) => arg.name));
+  const nextEntries = Object.entries(args).filter(([argName]) => declaredNames.has(argName));
+  if (nextEntries.length === Object.keys(args).length) {
+    return args;
+  }
+  return nextEntries.length > 0 ? Object.fromEntries(nextEntries) : void 0;
+};
+var pruneNodeSlotsByDefinition = (slots, slotDefs) => {
+  if (!slots) {
+    return slots;
+  }
+  if (!slotDefs?.length) {
+    return void 0;
+  }
+  const lastIndex = slotDefs.length - 1;
+  const keepVariadicTail = parseSlotDefinition(
+    slotDefs[lastIndex] ?? "",
+    slotDefs,
+    lastIndex
+  ).variadic;
+  const nextSlots = keepVariadicTail ? slots.slice(0) : slots.slice(0, slotDefs.length);
+  return isJsonEqual(nextSlots, slots) ? slots : nextSlots;
+};
 var matchesSelectedNodeTarget = (selectedNode, payload) => {
   return selectedNode.ref.structuralStableId === payload.target.structuralStableId && selectedNode.ref.sourceStableId === payload.target.sourceStableId && selectedNode.ref.sourceTreePath === payload.target.sourceTreePath;
 };
@@ -220641,9 +221073,9 @@ var reduceUpdateNode = (mutation, context) => {
   }
   const nextDebug = payload.data.debug ? true : void 0;
   const nextDisabled = payload.data.disabled ? true : void 0;
-  const nextInput = payload.data.input;
-  const nextOutput = payload.data.output;
-  const nextArgs = payload.data.args;
+  const nextInput = pruneNodeSlotsByDefinition(payload.data.input, nextNodeDef?.input);
+  const nextOutput = pruneNodeSlotsByDefinition(payload.data.output, nextNodeDef?.output);
+  const nextArgs = pruneNodeArgsByDefinition(payload.data.args, nextNodeDef);
   if (nextName === selectedNode.data.name && nextDesc === selectedNode.data.desc && nextPath === selectedNode.data.path && nextDebug === selectedNode.data.debug && nextDisabled === selectedNode.data.disabled && isJsonEqual(nextInput ?? [], selectedNode.data.input ?? []) && isJsonEqual(nextOutput ?? [], selectedNode.data.output ?? []) && isJsonEqual(nextArgs ?? {}, selectedNode.data.args ?? {})) {
     return { status: "noop" };
   }
@@ -221273,7 +221705,8 @@ function createSessionDispatcher({
   handleSaveDocumentMessage,
   handleRevertDocumentMessage,
   refreshSettings,
-  handleValidateNodeChecksMessage,
+  handleValidateNodeFieldsMessage,
+  handleResolveNodeFieldVisibilityMessage,
   fileRequestHandlers
 }) {
   const dispatchEditorMessage = async (msg, reply = postMessage, source = "editor") => {
@@ -221321,8 +221754,11 @@ function createSessionDispatcher({
       case "runInspectorCommand":
         void vscode14.commands.executeCommand(msg.command).then(void 0, logAsyncRuntimeError(`command:${msg.command}`));
         return;
-      case "validateNodeChecks":
-        await handleValidateNodeChecksMessage(msg, reply);
+      case "validateNodeFields":
+        await handleValidateNodeFieldsMessage(msg, reply);
+        return;
+      case "resolveNodeFieldVisibility":
+        await handleResolveNodeFieldVisibilityMessage(msg, reply);
         return;
       case "webviewLog":
         writeWebviewLogMessage(msg);
@@ -221534,6 +221970,7 @@ async function createSessionNodeCheckRuntime({
         null,
         createSessionBuildScriptEnv(workspaceFolderUri.fsPath, nodeDefs)
       ),
+      nodeFieldVisibleHandlers: /* @__PURE__ */ new Map(),
       treePath: workspaceFolderUri.fsPath
     };
   }
@@ -221570,11 +222007,17 @@ async function createSessionNodeCheckRuntime({
     checkScriptModules,
     env2
   );
+  const visibleRuntime = createNodeFieldVisibleRuntimeWithCheckModules(
+    buildScriptModule,
+    checkScriptModules,
+    env2
+  );
   return {
     buildScriptRuntime: {
       ...buildScriptRuntime,
       hasError: buildScriptRuntime.hasError || hasRuntimeLoadError
     },
+    nodeFieldVisibleHandlers: visibleRuntime.nodeFieldVisibles,
     treePath: workdir
   };
 }
@@ -221591,15 +222034,15 @@ function createSessionNodeChecks(context) {
       readWorkspaceFileContent
     });
   };
-  const handleValidateNodeChecksMessage = async (msg, reply = postMessage) => {
+  const handleValidateNodeFieldsMessage = async (msg, reply = postMessage) => {
     try {
       const runtimeResult = await createNodeCheckRuntime();
       const tree = JSON.parse(msg.content);
-      const diagnostics = collectNodeArgCheckDiagnostics({
+      const diagnostics = collectNodeFieldCheckDiagnostics({
         tree,
         treePath: msg.treePath || runtimeResult.treePath,
         env: createSessionBuildScriptEnv(runtimeResult.treePath, state.nodeDefs),
-        checkers: runtimeResult.buildScriptRuntime.nodeArgCheckers,
+        checkers: runtimeResult.buildScriptRuntime.nodeFieldCheckers,
         targets: msg.nodes.map((entry) => ({
           instanceKey: entry.instanceKey,
           treePath: entry.treePath,
@@ -221607,13 +222050,15 @@ function createSessionNodeChecks(context) {
         }))
       });
       await reply({
-        type: "validateNodeChecksResult",
+        type: "validateNodeFieldsResult",
         requestId: msg.requestId,
         diagnostics: diagnostics.filter(
           (diagnostic) => typeof diagnostic.instanceKey === "string"
         ).map((diagnostic) => ({
           instanceKey: diagnostic.instanceKey,
-          argName: diagnostic.argName,
+          fieldKind: diagnostic.fieldKind,
+          fieldName: diagnostic.fieldName,
+          fieldIndex: diagnostic.fieldIndex,
           checker: diagnostic.checker,
           message: diagnostic.message
         })),
@@ -221624,15 +222069,42 @@ function createSessionNodeChecks(context) {
       });
     } catch (error) {
       await reply({
-        type: "validateNodeChecksResult",
+        type: "validateNodeFieldsResult",
         requestId: msg.requestId,
         diagnostics: [],
         error: String(error)
       });
     }
   };
+  const handleResolveNodeFieldVisibilityMessage = async (msg, reply = postMessage) => {
+    try {
+      const runtimeResult = await createNodeCheckRuntime();
+      const tree = JSON.parse(msg.content);
+      const visibility = resolveNodeFieldVisibility({
+        tree,
+        treePath: msg.treePath || runtimeResult.treePath,
+        env: createSessionBuildScriptEnv(runtimeResult.treePath, state.nodeDefs),
+        visibles: runtimeResult.nodeFieldVisibleHandlers,
+        target: toNodeData(msg.target.node),
+        targetTreePath: msg.target.treePath
+      });
+      await reply({
+        type: "resolveNodeFieldVisibilityResult",
+        requestId: msg.requestId,
+        visibility
+      });
+    } catch (error) {
+      await reply({
+        type: "resolveNodeFieldVisibilityResult",
+        requestId: msg.requestId,
+        visibility: { args: {}, input: {}, output: {} },
+        error: String(error)
+      });
+    }
+  };
   return {
-    handleValidateNodeChecksMessage
+    handleValidateNodeFieldsMessage,
+    handleResolveNodeFieldVisibilityMessage
   };
 }
 
@@ -221964,10 +222436,7 @@ async function resolveTreeEditorSession(params) {
   const inspectorSync = createSessionInspectorSync(context);
   const subtreeTracking = createSessionSubtreeTracking(context, inspectorSync);
   const fileVersionGuard = createFileVersionGuard(context);
-  const {
-    getActiveNewerFileEditMessage,
-    getExistingNewerFileEditMessage
-  } = fileVersionGuard;
+  const { getActiveNewerFileEditMessage, getExistingNewerFileEditMessage } = fileVersionGuard;
   const { refreshSettings } = createSessionSettingsSync(context, inspectorSync);
   const selectionSync = createSessionSelectionSync(context, inspectorSync);
   const { handleSelectTreeMessage, handleSelectNodeMessage } = selectionSync;
@@ -221983,7 +222452,7 @@ async function resolveTreeEditorSession(params) {
     handleRevertDocumentMessage,
     handleMainDocumentFileChange
   } = createSessionDocumentLifecycle(context, inspectorSync, subtreeTracking, fileVersionGuard);
-  const { handleValidateNodeChecksMessage } = createSessionNodeChecks(context);
+  const { handleValidateNodeFieldsMessage, handleResolveNodeFieldVisibilityMessage } = createSessionNodeChecks(context);
   const fileRequestHandlers = createSessionFileRequestHandlers({
     projectRootUri,
     viewType,
@@ -222010,7 +222479,8 @@ async function resolveTreeEditorSession(params) {
     handleSaveDocumentMessage,
     handleRevertDocumentMessage,
     refreshSettings,
-    handleValidateNodeChecksMessage,
+    handleValidateNodeFieldsMessage,
+    handleResolveNodeFieldVisibilityMessage,
     fileRequestHandlers
   });
   const activeWebviewEntry = {
@@ -222974,14 +223444,22 @@ var InspectorSidebarCoordinator = class {
           error
         });
         return;
-      case "validateNodeChecks":
+      case "validateNodeFields":
         await reply({
-          type: "validateNodeChecksResult",
+          type: "validateNodeFieldsResult",
           requestId: message.requestId,
           diagnostics: [],
           error
         });
         return;
+      case "resolveNodeFieldVisibility":
+        await reply({
+          type: "resolveNodeFieldVisibilityResult",
+          requestId: message.requestId,
+          visibility: { args: {}, input: {}, output: {} },
+          error
+        });
+        return;
       case "ready":
       case "undo":
       case "redo":
@@ -223128,19 +223606,19 @@ function createCheckerScriptContent(baseName) {
   const className = ensureSuffix(toPascalIdentifier(baseName), "Checker");
   const checkerName = toCheckerRegistrationName(baseName);
   return [
-    'import type { NodeArgCheckContext } from "vscode-behavior3/build";',
+    'import type { NodeFieldCheckContext } from "vscode-behavior3/build";',
     "",
     `@behavior3.check("${checkerName}")`,
     `export class ${className} {`,
-    "    validate(value: unknown, ctx: NodeArgCheckContext) {",
+    "    validate(value: unknown, ctx: NodeFieldCheckContext) {",
     '        if (value === undefined || value === null || value === "") {',
     "            return;",
     "        }",
     '        if (typeof value !== "number") {',
-    "            return `${ctx.argName} must be a number`;",
+    "            return `${ctx.fieldName} must be a number`;",
     "        }",
     "        if (value <= 0) {",
-    "            return `${ctx.argName} must be greater than 0`;",
+    "            return `${ctx.fieldName} must be greater than 0`;",
     "        }",
     "    }",
     "}",