vscode-behavior3 2.3.0 → 2.5.0

package/dist/build-cli.js

@@ -212364,16 +212364,22 @@ var hasArgOptions = (arg) => arg.options !== void 0;
 // webview/shared/node-utils.ts
 var createNodeDefMap = (nodeDefs) => new Map(nodeDefs.map((nodeDef) => [nodeDef.name, nodeDef]));
 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) => {
@@ -212496,10 +212502,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) {
@@ -212513,7 +212516,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;
@@ -212559,6 +212562,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 [];
@@ -212573,6 +212582,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) => {
@@ -212683,44 +212720,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),
@@ -212874,7 +212910,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),
@@ -213034,10 +213070,10 @@ var collectReachableSubtreePaths = (root) => {
   });
   return Array.from(paths);
 };
-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;
   }
@@ -213060,7 +213096,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?.({
@@ -213358,6 +213394,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,
@@ -213384,12 +213422,30 @@ 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;
@@ -213474,7 +213530,7 @@ var createBatchHooks = (moduleExports, env, reportMissing = true) => {
   }
   return void 0;
 };
-var createNodeArgCheckers = (moduleExports, env) => {
+var createNodeFieldCheckers = (moduleExports, env) => {
   const checkers = /* @__PURE__ */ new Map();
   let hasError = false;
   if (!moduleExports || typeof moduleExports !== "object") {
@@ -213512,7 +213568,7 @@ var createNodeArgCheckers = (moduleExports, env) => {
 var createBuildScriptRuntime = (moduleExports, env) => {
   if (!moduleExports || typeof moduleExports !== "object") {
     return {
-      nodeArgCheckers: /* @__PURE__ */ new Map(),
+      nodeFieldCheckers: /* @__PURE__ */ new Map(),
       hasError: false,
       hasEntries: false
     };
@@ -213520,7 +213576,7 @@ var createBuildScriptRuntime = (moduleExports, env) => {
   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, env, false);
-  const checkerResult = createNodeArgCheckers(moduleExports, env);
+  const checkerResult = createNodeFieldCheckers(moduleExports, env);
   const hasEntries = Boolean(buildScript) || checkerResult.hasCheckers;
   if (!hasEntries) {
     logger.error(
@@ -213529,39 +213585,35 @@ var createBuildScriptRuntime = (moduleExports, env) => {
   }
   return {
     buildScript,
-    nodeArgCheckers: checkerResult.checkers,
+    nodeFieldCheckers: checkerResult.checkers,
     hasError: checkerResult.hasError || !hasEntries || hasBuildHookCandidate && !buildScript,
     hasEntries
   };
 };
 var createBuildScriptRuntimeWithCheckModules = (buildScriptModule, checkScriptModules, env) => {
   const runtime = createBuildScriptRuntime(buildScriptModule, env);
-  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, env);
+    const checkerResult = createNodeFieldCheckers(checkScript.moduleExports, env);
     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
   };
@@ -213707,7 +213759,7 @@ var processBatchTree = (tree, treePath, batch, errors) => {
   }
   return tree;
 };
-var normalizeNodeArgCheckResult = (result) => {
+var normalizeNodeFieldCheckResult = (result) => {
   if (Array.isArray(result)) {
     return result.filter((entry) => typeof entry === "string" && entry.trim());
   }
@@ -213725,7 +213777,99 @@ 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 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 : (() => {
@@ -213739,47 +213883,100 @@ var collectNodeArgCheckDiagnostics = (params) => {
     if (!nodeDef) {
       continue;
     }
-    for (const arg of nodeDef.args ?? []) {
-      const checkerName = arg.checker?.trim();
-      if (!checkerName) {
-        continue;
-      }
-      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;
-      }
-      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
-          })
-        );
-        messages.forEach(pushDiagnostic);
-      } catch (error) {
-        pushDiagnostic(`checker '${checkerName}' failed: ${formatRuntimeError(error)}`);
+    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)}`);
+        }
       }
-    }
+    });
   }
   return diagnostics;
 };
-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;
@@ -213946,7 +214143,8 @@ var applyBehavior3DecoratorGlobal = () => {
     ...decoratorGlobalState.previousBehavior3 && typeof decoratorGlobalState.previousBehavior3 === "object" ? decoratorGlobalState.previousBehavior3 : {},
     build: markBuildHook,
     batch: markBatchHook,
-    check: markCheckHook
+    check: markCheckHook,
+    visible: markVisibleHook
   };
 };
 var restoreBehavior3DecoratorGlobal = () => {
@@ -214256,16 +214454,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) {
@@ -214988,6 +215186,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];
@@ -215048,17 +215252,24 @@ function registerNode(cls) {
     descriptor
   });
 }
-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;
@@ -215079,9 +215290,6 @@ var Stack = class {
       this.pop();
     }
   }
-  move(dest, start, count) {
-    dest._nodes.push(...this._nodes.splice(start, count));
-  }
   clear() {
     this.popTo(0);
   }
@@ -215990,7 +216198,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") {
@@ -216002,9 +216210,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;
@@ -216050,7 +216258,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") {
@@ -216060,9 +216268,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";
@@ -216298,7 +216506,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);
@@ -216309,9 +216517,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;
@@ -217137,7 +217345,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);
@@ -217150,11 +217358,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;
@@ -217177,6 +217385,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
@@ -217235,6 +217444,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;
@@ -217349,6 +217566,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 = {
@@ -217432,6 +217671,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) {
@@ -217472,14 +217715,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;
 };
@@ -217551,6 +217795,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 = [];
       }
@@ -217558,7 +217803,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)) {
@@ -217572,6 +217817,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 = [];
       }
@@ -217579,7 +217825,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)) {