vscode-behavior3 2.3.3 → 2.5.1

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) => {
@@ -212576,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) => {
@@ -212686,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),
@@ -213361,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,
@@ -213387,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;
@@ -213477,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") {
@@ -213515,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
     };
@@ -213523,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(
@@ -213532,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
   };
@@ -213710,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());
   }
@@ -213728,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 : (() => {
@@ -213742,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;
@@ -213949,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 = () => {
@@ -214259,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) {
@@ -214991,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];
@@ -215051,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;
@@ -215082,9 +215290,6 @@ var Stack = class {
       this.pop();
     }
   }
-  move(dest, start, count) {
-    dest._nodes.push(...this._nodes.splice(start, count));
-  }
   clear() {
     this.popTo(0);
   }
@@ -215993,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") {
@@ -216005,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;
@@ -216053,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") {
@@ -216063,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";
@@ -216301,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);
@@ -216312,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;
@@ -217140,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);
@@ -217153,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;
@@ -217180,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
@@ -217589,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 = [];
       }
@@ -217596,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)) {
@@ -217610,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 = [];
       }
@@ -217617,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)) {
@@ -217844,6 +218052,13 @@ var isValidInputOrOutput = (def, data, index) => {
 // src/project-path-discovery.ts
 var fs = __toESM(require("fs"));
 var path = __toESM(require("path"));
+var resolveExistingPath = (inputPath) => {
+  const resolved = path.resolve(inputPath);
+  if (!fs.existsSync(resolved)) {
+    return resolved;
+  }
+  return fs.realpathSync.native(resolved);
+};
 var isWithinRoot = (rootDir, candidateDir) => {
   const relative3 = path.relative(rootDir, candidateDir);
   return relative3 === "" || !relative3.startsWith("..") && !path.isAbsolute(relative3);
@@ -217853,12 +218068,13 @@ var toSearchDirectory = (inputPath) => {
   if (!fs.existsSync(resolved)) {
     return path.extname(resolved) ? path.dirname(resolved) : resolved;
   }
-  const stat = fs.statSync(resolved);
-  return stat.isDirectory() ? resolved : path.dirname(resolved);
+  const canonical = resolveExistingPath(resolved);
+  const stat = fs.statSync(canonical);
+  return stat.isDirectory() ? canonical : path.dirname(canonical);
 };
 var findNearestFileUpward = (searchFrom, suffix, rootDir) => {
-  let dir = path.resolve(searchFrom);
-  const boundary = rootDir ? path.resolve(rootDir) : void 0;
+  let dir = resolveExistingPath(searchFrom);
+  const boundary = rootDir ? resolveExistingPath(rootDir) : void 0;
   while (true) {
     if (boundary && !isWithinRoot(boundary, dir)) {
       break;
@@ -217867,7 +218083,7 @@ var findNearestFileUpward = (searchFrom, suffix, rootDir) => {
       const names = fs.readdirSync(dir);
       const hit = names.filter((name) => name.endsWith(suffix)).sort()[0];
       if (hit) {
-        return path.join(dir, hit);
+        return resolveExistingPath(path.join(dir, hit));
       }
     } catch {
     }
@@ -217885,14 +218101,14 @@ var findNearestFileUpward = (searchFrom, suffix, rootDir) => {
 var findBehaviorWorkspaceFileSync = (searchPath, opts) => {
   const resolved = path.resolve(searchPath);
   if (resolved.endsWith(".b3-workspace") && fs.existsSync(resolved)) {
-    return resolved;
+    return resolveExistingPath(resolved);
   }
   return findNearestFileUpward(toSearchDirectory(resolved), ".b3-workspace", opts?.rootDir);
 };
 var findBehaviorSettingFileSync = (searchPath, opts) => {
   const resolved = path.resolve(searchPath);
   if (resolved.endsWith(".b3-setting") && fs.existsSync(resolved)) {
-    return resolved;
+    return resolveExistingPath(resolved);
   }
   return findNearestFileUpward(toSearchDirectory(resolved), ".b3-setting", opts?.rootDir);
 };
@@ -217900,6 +218116,25 @@ var findBehaviorSettingFileSync = (searchPath, opts) => {
 // src/build/build-cli.ts
 setFs(fs2);
 var normalizePosixPath = (filePath) => filePath.replace(/\\/g, "/");
+var resolveExistingPath2 = (filePath) => {
+  const resolved = path2.resolve(filePath);
+  if (!fs2.existsSync(resolved)) {
+    return resolved;
+  }
+  return fs2.realpathSync.native(resolved);
+};
+async function withProcessCwd(cwd, run) {
+  const previousCwd = process.cwd();
+  if (previousCwd === cwd) {
+    return run();
+  }
+  process.chdir(cwd);
+  try {
+    return await run();
+  } finally {
+    process.chdir(previousCwd);
+  }
+}
 var ensureExistingFile = (filePath, suffix, label) => {
   const resolved = path2.resolve(filePath);
   if (!resolved.endsWith(suffix)) {
@@ -217908,7 +218143,7 @@ var ensureExistingFile = (filePath, suffix, label) => {
   if (!fs2.existsSync(resolved) || !fs2.statSync(resolved).isFile()) {
     throw new Error(`${label} does not exist: ${resolved}`);
   }
-  return resolved;
+  return resolveExistingPath2(resolved);
 };
 var ensureExistingScriptFile = (filePath, label) => {
   const resolved = path2.resolve(filePath);
@@ -217919,7 +218154,7 @@ var ensureExistingScriptFile = (filePath, label) => {
   if (!fs2.existsSync(resolved) || !fs2.statSync(resolved).isFile()) {
     throw new Error(`${label} does not exist: ${resolved}`);
   }
-  return resolved;
+  return resolveExistingPath2(resolved);
 };
 var resolveBehaviorProjectPaths = (options) => {
   const projectPath = path2.resolve(options.projectPath ?? process.cwd());
@@ -217967,10 +218202,13 @@ var buildBehaviorProject = async (options) => {
       alertError: () => {
       }
     });
-    const hasError = await buildProjectWithContext(
-      normalizePosixPath(paths.workspaceFile),
-      normalizePosixPath(paths.outputDir),
-      buildContext
+    const hasError = await withProcessCwd(
+      paths.workdir,
+      async () => buildProjectWithContext(
+        normalizePosixPath(paths.workspaceFile),
+        normalizePosixPath(paths.outputDir),
+        buildContext
+      )
     );
     return {
       hasError,