vscode-behavior3 2.5.1 → 2.7.0

package/dist/build-cli.js

@@ -212351,7 +212351,7 @@ var stringifyJson = (data, option) => {
 };
 
 // webview/shared/b3type.ts
-var DOCUMENT_VERSION = "2.2.0";
+var DOCUMENT_VERSION = "2.7.0";
 var keyWords = ["true", "false", "null", "undefined", "NaN", "Infinity"];
 var isIntType = (type) => type.startsWith("int");
 var isFloatType = (type) => type.startsWith("float");
@@ -212428,6 +212428,473 @@ var checkOneof = (arg, argValue, inputValue) => {
   return normalizedArgValue !== "" && normalizedInputValue === "" || normalizedArgValue === "" && normalizedInputValue !== "";
 };
 
+// media/locales/en.json
+var en_default = {
+  about: "About Behavior3",
+  actuaSize: "Actual Size",
+  actualSize: "Actual Size",
+  add: "Add",
+  alertNewVersion: "This file is created by a newer version of Behavior3({{version}}), please upgrade to the latest version.",
+  batch: "Batch Script",
+  batchCompleted: "Batch completed",
+  batchFailed: "Batch failed, more information can be found in the console.",
+  build: "Build",
+  buildCompleted: "Build completed",
+  buildFailed: "Build failed, more information can be found in the console.",
+  cancel: "Cancel",
+  compact: "Compact",
+  console: "Console",
+  copy: "Copy",
+  createProject: "Create Project",
+  checkExpr: "Check expression",
+  cut: "Cut",
+  delete: "Delete",
+  deleteNode: "Delete Node",
+  devTools: "Toggle Developer Tools",
+  donotSave: "Don't Save",
+  duplicate: "Duplicate",
+  editSubtree: "Edit Subtree",
+  fieldRequired: "Field '{{field}}' is required",
+  forceReload: "Force Reload",
+  fullscreen: "Toggle Full Screen",
+  hide: "Hide Behavior3",
+  hideOthers: "Hide Others",
+  insertNode: "Insert Node",
+  jumpNode: "Jump Node",
+  language: "Language",
+  moveToTrash: "Move to Trash",
+  newFile: "New File...",
+  newFolder: "New Folder...",
+  newWindow: "New Window",
+  nodeDefinition: "NODES",
+  normal: "Normal",
+  open: "Open...",
+  openProject: "Open Project",
+  paste: "Paste",
+  quit: "Quit Behavior3",
+  recent: "Recent",
+  redo: "Redo",
+  reload: "Reload",
+  reset: "Reset",
+  "reset.confirm": "Reset to original value?",
+  "reset.defaultConfirm": "Reset to default value?",
+  rename: "Rename...",
+  replace: "Replace",
+  reportIssue: "Report Issue",
+  revealFileOnMac: "Reveal in Finder",
+  revealFileOnWindows: "Reveal in File Explorer",
+  save: "Save",
+  saveAll: "Save All",
+  saveAs: "Save As...",
+  saveAsSubtree: "Save As Subtree",
+  searchFile: "Search File",
+  searchNode: "Search Node",
+  selectAll: "Select All",
+  services: "Services",
+  setupBuildScript: "Setup Build Script",
+  start: "Start",
+  undo: "Undo",
+  unhide: "Show All",
+  zoomIn: "Zoom In",
+  zoomOut: "Zoom Out",
+  "menu.edit": "Edit",
+  "menu.file": "File",
+  "menu.view": "View",
+  "menu.window": "Window",
+  "menu.help": "Help",
+  "workspace.saveAllOnClose": "Do you want to save the changes to the following {{count}} files?",
+  "workspace.saveOnClose": "Do you want to save the changes you made to '{{name}}'?",
+  "workspace.reloadFile": "'{{name}}' has changed, do you want to reload now?",
+  "explorer.deleteFile": "Are you sure you want delete '{{name}}'?",
+  "explorer.deleteFolder": "Are you sure you want delete '{{name}}' and its contents?",
+  "explorer.replaceFile": "Are you sure you want replace '{{name}}'?",
+  "explorer.restoreFileInfo": "You can restore this file from the Trash.",
+  "explorer.title": "Explorer",
+  "tree.overview": "Overview",
+  "tree.name": "Tree name",
+  "tree.desc": "Tree desc",
+  "tree.export": "Export",
+  "tree.prefix": "ID prefix",
+  "tree.group": "Enable Node Grouping",
+  "tree.group.placeholder": "Select node groups",
+  "tree.vars": "Define Variables",
+  "tree.vars.local": "Local Variables",
+  "tree.vars.add": "Add Variable",
+  "tree.vars.name": "name",
+  "tree.vars.invalidName": "Invalid variable name",
+  "tree.vars.desc": "description",
+  "tree.vars.imports": "Import Variables",
+  "tree.vars.subtree": "Subtree Variables",
+  "tree.import.add": "Add Import",
+  "tree.custom": "Custom Data",
+  "tree.custom.add": "Add Entry",
+  "tree.custom.key": "key",
+  "tree.custom.value": "value",
+  "tree.custom.type.string": "String value",
+  "tree.custom.type.number": "Number value",
+  "tree.custom.type.boolean": "Boolean value",
+  "tree.custom.type.invalid": "Invalid custom value",
+  "regnode.input": "Input: ",
+  "regnode.output": "Output: ",
+  "regnode.args": "Args: ",
+  "regnode.mark": "Mark: ",
+  "regnode.subtree": "Subtree: ",
+  "node.args": "Const arguments",
+  "node.children.unlimited": "Unlimited",
+  "node.children": "Num children",
+  "node.debug": "Debug",
+  "node.deleteRootNodeDenied": "Unable to delete the root node",
+  "node.dropDenied": "This node position is denied to drop the node",
+  "node.desc": "Node desc",
+  "node.disabled": "Disabled",
+  "node.editSubtreeDenied": "Unable to edit the subtree node",
+  "node.editFailed": "Node '{{name}}' edit failed",
+  "node.group": "Node group",
+  "node.groupNotEnabled": "One of '{{group}}' node group is not enabled in current file",
+  "node.id": "Node id",
+  "node.inputVariable": "Input variables",
+  "node.invalidChildren": "Invalid number of children",
+  "node.invalidExpression": "Invalid expression",
+  "node.invalidValue": "Invalid value",
+  "node.invalidVariableName": "Invalid variable name, should start with a letter or underscore",
+  "node.name": "Node name",
+  "node.noNodeSelected": "No node selected",
+  "node.notFound": "Node '{{name}}' not found",
+  "node.oneof.error": "Only one is allowed between input '{{input}}' and argument '{{desc}}({{arg}})'",
+  "node.oneof.inputNotfound": "Input '{{input}}' not found",
+  "node.outputVariable": "Output variables",
+  "node.pasteDataError": "Paste data error",
+  "node.rootNodeAsSubtree": "Root node cann't be save as subtree",
+  "node.subtree": "Subtree",
+  "node.subtreeMissing": "Subtree file is missing: {{path}}",
+  "node.subtreeInvalid": "Subtree file is invalid: {{path}}",
+  "node.subtreeCyclic": "Subtree reference is cyclic: {{path}}",
+  "node.subtreeOpenFailed": "Failed to open subtree: file not found or unreadable ({{path}})",
+  "node.subtreePathError": "You should save the subtree inside the current workspace",
+  "node.subtreeSaveRootError": "Root node cann't be save as subtree",
+  "node.subtreeSaveSuccess": "Saved and converted to subtree node: {{path}}",
+  "node.moveSubtreeDenied": "Cannot move nodes inside a subtree",
+  "node.dropSubtreeInternalDenied": "Cannot drop onto a subtree internal node",
+  "node.moveRootDenied": "Cannot move the root node",
+  "node.dropAroundRootDenied": "Cannot place a node before or after the root",
+  "node.addChildToSubtreeRefDenied": "Cannot add child nodes to a subtree reference",
+  "node.moveIntoDescendantDenied": "Cannot move a node into its own descendant",
+  "node.type": "Node type",
+  "node.undefinedVariable": "Variable '{{variable}}' is not defined",
+  "node.jsonData": "JSON Data",
+  "node.unknown.title": "Unknown Node",
+  "node.unknownType": "Unknown",
+  "node.resolutionError": "Resolution Error",
+  "node.unknown.desc": "New node",
+  "build.success": "Build completed.",
+  "build.failed": "Build failed.",
+  "editor.loading": "Loading editor...",
+  "editor.externalChangeConflict": "External file change detected while the document has unsaved edits.",
+  "editor.reloadFromDisk": "Reload",
+  "editor.dismissConflict": "Dismiss",
+  "editor.newerVersionEditDenied": "This file is created by a newer version of Behavior3({{version}}). Please upgrade to the latest version.",
+  "inspector.noActiveDocument": "Open a Behavior3 editor to inspect and edit the active tree.",
+  "inspector.embeddedModeNotice": "Inspector is configured to appear inside the Behavior3 editor.",
+  "inspector.embeddedToolbar.build": "Build Behavior Tree",
+  "inspector.embeddedToolbar.toggleEditorMode": "Toggle Editor Mode",
+  "inspector.embeddedToolbar.toggleInspectorNodeJson": "Toggle Raw Node JSON",
+  "inspector.embeddedToolbar.createProject": "Create Project",
+  "inspector.embeddedToolbar.createTree": "Create Behavior Tree",
+  "mutation.invalidJsonPath": "Invalid JSON path: {{path}}",
+  "mutation.missingSelectedNode": "No selected node is available for this mutation.",
+  "mutation.selectedNodeMismatch": "The selected node changed before the mutation was applied.",
+  "mutation.missingTargetNode": "The target node could not be found.",
+  "mutation.missingSourceNode": "The source node could not be found.",
+  "mutation.missingSubtreeOriginal": "Missing subtree original snapshot for this mutation.",
+  "mutation.missingDetachedSubtreeRoot": "Missing detached subtree snapshot for this mutation.",
+  "mutation.moveRootDenied": "Cannot move the root node.",
+  "mutation.dropAroundRootDenied": "Cannot drop before or after the root node.",
+  "mutation.addChildToSubtreeRefDenied": "Cannot add a child directly to a subtree reference.",
+  "mutation.moveIntoDescendantDenied": "Cannot move a node into its own descendant.",
+  "mutation.deleteRootNodeDenied": "Cannot delete the root node.",
+  "mutation.editSubtreeDenied": "Cannot edit structure on a subtree reference.",
+  "mutation.saveSelectedAsSubtreeRootDenied": "The root node cannot be saved as a subtree.",
+  "mutation.saveSelectedAsSubtreeMissingTarget": "The target node could not be saved as a subtree.",
+  "mutation.saveSelectedAsSubtreePostSaveMissingTarget": "The target node could not be found after saving the subtree.",
+  "runtime.nodeCheckRuntimeHasErrors": "Checker runtime has errors.",
+  "runtime.invalidSavedSubtreePath": "Host returned an invalid saved subtree path.",
+  "runtime.unsupportedDocumentMutation": "Unsupported document mutation.",
+  "runtime.visibleHookNotRegistered": "Visible '{{name}}' is not registered.",
+  "runtime.visibleHookFailed": "Visible '{{name}}' failed: {{error}}",
+  "runtime.visibleExpressionDisabled": "Visible expression is disabled; enable settings.allowNewFunction.",
+  "runtime.visibleExpressionCompileFailed": "Visible expression failed to compile: {{error}}",
+  "runtime.visibleExpressionFailed": "Visible expression failed: {{error}}",
+  "runtime.visibleExpressionUnknownArg": "Visible expression referenced args.{{property}}, but '{{property}}' is not in the defined arg scope (defined args: {{definedArgs}}).",
+  "runtime.visibleExpressionNoArgs": "Visible expression referenced args.{{property}}, but this node defines no args.",
+  "runtime.visibleExpressionUnknownSlotIndex": "Visible expression referenced {{fieldKind}}[{{index}}], but {{definedScope}}.",
+  "runtime.visibleExpressionInvalidSlotProperty": "Visible expression referenced {{fieldKind}}.{{property}}, but {{fieldKind}} only supports defined numeric slot indices.",
+  "runtime.visibleSlotScopeNone": "this node defines no {{fieldKind}} slots",
+  "runtime.visibleSlotScopeIndex": "the defined {{fieldKind}} index is {{start}}",
+  "runtime.visibleSlotScopeRange": "the defined {{fieldKind}} indices are {{start}}..{{end}}",
+  "runtime.visibleSlotScopeRangeVariadic": "the defined {{fieldKind}} indices are {{start}}..{{end}}+",
+  "override.resetTitle": "Reset this override?",
+  "form.enterJsonArray": "Enter JSON array",
+  "form.enterJsonValue": "Enter JSON value",
+  "form.unset": "Unset",
+  "form.true": "True",
+  "form.false": "False",
+  "validation.jsonArray": "{{name}} must be a JSON array",
+  "validation.integer": "{{field}} must be an integer",
+  "validation.number": "{{field}} must be a number",
+  "validation.missingOneofInput": "Missing input slot for oneof '{{input}}'",
+  "validation.oneof": "Only one of '{{left}}' and '{{right}}' can be set",
+  "validation.invalidJsonPath": "Path must be a workdir-relative .json file: {{path}}",
+  "validation.variableDescriptionRequired": "Variable description is required",
+  "validation.customKeyRequired": "Custom key is required",
+  "validation.customKeyDuplicate": "Custom key '{{key}}' is duplicated",
+  "validation.customValueInvalid": "Custom value must be a string, number, or boolean"
+};
+
+// media/locales/zh.json
+var zh_default = {
+  about: "\u5173\u4E8E Behavior3",
+  actualSize: "\u5B9E\u9645\u5927\u5C0F",
+  add: "\u6DFB\u52A0",
+  alertNewVersion: "\u6B64\u6587\u4EF6\u7531\u65B0\u7248\u672C Behavior3({{version}}) \u521B\u5EFA\uFF0C\u8BF7\u5347\u7EA7\u5230\u6700\u65B0\u7248\u672C\u3002",
+  batch: "\u6279\u5904\u7406\u811A\u672C",
+  batchCompleted: "\u6279\u5904\u7406\u5B8C\u6210",
+  batchFailed: "\u6279\u5904\u7406\u51FA\u73B0\u9519\u8BEF\uFF0C\u8BE6\u60C5\u8BF7\u67E5\u770B\u63A7\u5236\u53F0\uFF01",
+  build: "\u6784\u5EFA",
+  buildCompleted: "\u6784\u5EFA\u5B8C\u6210",
+  buildFailed: "\u6784\u5EFA\u51FA\u73B0\u9519\u8BEF\uFF0C\u8BE6\u60C5\u8BF7\u67E5\u770B\u63A7\u5236\u53F0\uFF01",
+  cancel: "\u53D6\u6D88",
+  compact: "\u7D27\u51D1",
+  console: "\u63A7\u5236\u53F0",
+  checkExpr: "\u68C0\u67E5\u8868\u8FBE\u5F0F",
+  copy: "\u590D\u5236",
+  createProject: "\u65B0\u5EFA\u9879\u76EE",
+  cut: "\u526A\u5207",
+  delete: "\u5220\u9664",
+  deleteNode: "\u5220\u9664\u8282\u70B9",
+  devTools: "\u5207\u6362\u5F00\u53D1\u8005\u5DE5\u5177",
+  donotSave: "\u4E0D\u4FDD\u5B58",
+  duplicate: "\u751F\u6210\u526F\u672C",
+  editSubtree: "\u7F16\u8F91\u5B50\u6811",
+  fieldRequired: "\u5B57\u6BB5\u201C{{field}}\u201D\u5FC5\u586B",
+  forceReload: "\u5F3A\u5236\u91CD\u65B0\u52A0\u8F7D",
+  fullscreen: "\u5207\u6362\u5168\u5C4F",
+  hide: "\u9690\u85CF Behavior3",
+  hideOthers: "\u9690\u85CF\u5176\u5B83",
+  insertNode: "\u63D2\u5165\u8282\u70B9",
+  jumpNode: "\u8DF3\u8F6C\u8282\u70B9",
+  language: "\u8BED\u8A00",
+  moveToTrash: "\u79FB\u81F3\u56DE\u6536\u7AD9",
+  newFile: "\u65B0\u5EFA\u884C\u4E3A\u6811...",
+  newFolder: "\u65B0\u5EFA\u76EE\u5F55...",
+  newWindow: "\u65B0\u5EFA\u7A97\u53E3",
+  nodeDefinition: "\u8282\u70B9\u5B9A\u4E49",
+  normal: "\u6B63\u5E38",
+  open: "\u6253\u5F00...",
+  openProject: "\u6253\u5F00\u9879\u76EE",
+  paste: "\u7C98\u8D34",
+  quit: "\u9000\u51FA Behavior3",
+  recent: "\u6700\u8FD1\u6253\u5F00",
+  redo: "\u91CD\u505A",
+  reload: "\u91CD\u65B0\u52A0\u8F7D",
+  reset: "\u91CD\u7F6E",
+  "reset.confirm": "\u91CD\u7F6E\u4E3A\u539F\u59CB\u503C\uFF1F",
+  "reset.defaultConfirm": "\u91CD\u7F6E\u4E3A\u9ED8\u8BA4\u503C\uFF1F",
+  rename: "\u91CD\u547D\u540D...",
+  replace: "\u66FF\u6362",
+  reportIssue: "\u95EE\u9898\u53CD\u9988",
+  revealFileOnMac: "\u5728 Finder \u4E2D\u663E\u793A",
+  revealFileOnWindows: "\u5728\u6587\u4EF6\u7BA1\u7406\u5668\u4E2D\u6253\u5F00",
+  save: "\u4FDD\u5B58",
+  saveAll: "\u4FDD\u5B58\u5168\u90E8",
+  saveAs: "\u53E6\u5B58\u4E3A...",
+  saveAsSubtree: "\u53E6\u5B58\u4E3A\u5B50\u6811",
+  searchFile: "\u641C\u7D22\u6587\u4EF6",
+  searchNode: "\u641C\u7D22\u8282\u70B9",
+  selectAll: "\u5168\u9009",
+  services: "\u670D\u52A1",
+  setupBuildScript: "\u8BBE\u7F6E\u6784\u5EFA\u811A\u672C",
+  start: "\u5F00\u59CB",
+  undo: "\u64A4\u9500",
+  unhide: "\u663E\u793A\u6240\u6709",
+  zoomIn: "\u653E\u5927",
+  zoomOut: "\u7F29\u5C0F",
+  "menu.file": "\u6587\u4EF6",
+  "menu.edit": "\u7F16\u8F91",
+  "menu.view": "\u89C6\u56FE",
+  "menu.window": "\u7A97\u53E3",
+  "menu.help": "\u5E2E\u52A9",
+  "workspace.saveAllOnClose": "\u4F60\u9700\u8981\u4FDD\u5B58\u5BF9\u4EE5\u4E0B {{count}} \u4E2A\u6587\u4EF6\u7684\u4FEE\u6539\u5417\uFF1F",
+  "workspace.saveOnClose": "\u4F60\u9700\u8981\u4FDD\u5B58\u5BF9\u6587\u4EF6 {{name}} \u7684\u4FEE\u6539\u5417\uFF1F",
+  "workspace.reloadFile": "\u6587\u4EF6 {{name}} \u53D1\u751F\u6539\u53D8\uFF0C\u4F60\u9700\u8981\u91CD\u65B0\u52A0\u8F7D\u5417\uFF1F",
+  "explorer.deleteFile": "\u4F60\u786E\u5B9A\u8981\u5220\u9664\u6587\u4EF6 '{{name}}'\uFF1F",
+  "explorer.deleteFolder": "\u4F60\u786E\u5B9A\u8981\u5220\u9664\u76EE\u5F55 '{{name}}'\uFF1F",
+  "explorer.replaceFile": "\u4F60\u786E\u5B9A\u8981\u66FF\u6362\u6587\u4EF6 '{{name}}'\uFF1F",
+  "explorer.restoreFileInfo": "\u4F60\u53EF\u4EE5\u4ECE\u56DE\u6536\u7AD9\u6062\u590D\u6B64\u6587\u4EF6\u3002",
+  "explorer.title": "\u8D44\u6E90\u6D4F\u89C8",
+  "tree.overview": "\u6982\u51B5",
+  "tree.name": "\u884C\u4E3A\u6811",
+  "tree.desc": "\u8BF4\u660E",
+  "tree.export": "\u5BFC\u51FA",
+  "tree.prefix": "\u6807\u8BC6\u524D\u7F00",
+  "tree.group": "\u542F\u7528\u8282\u70B9\u5206\u7EC4",
+  "tree.group.placeholder": "\u9009\u62E9\u8282\u70B9\u5206\u7EC4",
+  "tree.vars": "\u5B9A\u4E49\u53D8\u91CF",
+  "tree.vars.local": "\u672C\u5730\u53D8\u91CF",
+  "tree.vars.add": "\u6DFB\u52A0\u53D8\u91CF",
+  "tree.vars.name": "\u53D8\u91CF\u540D",
+  "tree.vars.invalidName": "\u53D8\u91CF\u540D\u4E0D\u5408\u6CD5",
+  "tree.vars.desc": "\u53D8\u91CF\u8BF4\u660E",
+  "tree.vars.imports": "\u5BFC\u5165\u53D8\u91CF",
+  "tree.vars.subtree": "\u5B50\u6811\u53D8\u91CF",
+  "tree.import.add": "\u6DFB\u52A0\u5BFC\u5165",
+  "tree.custom": "\u81EA\u5B9A\u4E49\u6570\u636E",
+  "tree.custom.add": "\u6DFB\u52A0\u6761\u76EE",
+  "tree.custom.key": "\u952E",
+  "tree.custom.value": "\u503C",
+  "tree.custom.type.string": "\u5B57\u7B26\u4E32\u503C",
+  "tree.custom.type.number": "\u6570\u5B57\u503C",
+  "tree.custom.type.boolean": "\u5E03\u5C14\u503C",
+  "tree.custom.type.invalid": "\u975E\u6CD5\u7684\u81EA\u5B9A\u4E49\u503C",
+  "regnode.input": "\u8F93\u5165\uFF1A",
+  "regnode.output": "\u8F93\u51FA\uFF1A",
+  "regnode.args": "\u53C2\u6570\uFF1A",
+  "regnode.mark": "\u5907\u6CE8\uFF1A",
+  "regnode.subtree": "\u5B50\u6811\uFF1A",
+  "node.args": "\u5E38\u91CF\u53C2\u6570",
+  "node.children.unlimited": "\u65E0\u9650\u5236",
+  "node.children": "\u5B50\u8282\u70B9\u6570\u91CF",
+  "node.debug": "\u8C03\u8BD5",
+  "node.deleteRootNodeDenied": "\u4E0D\u80FD\u5220\u9664\u6839\u8282\u70B9",
+  "node.dropDenied": "\u6B64\u8282\u70B9\u4F4D\u7F6E\u4E0D\u5141\u8BB8\u653E\u7F6E\u62D6\u62FD\u7684\u8282\u70B9",
+  "node.desc": "\u8282\u70B9\u8BF4\u660E",
+  "node.disabled": "\u7981\u7528",
+  "node.editSubtreeDenied": "\u4E0D\u80FD\u7F16\u8F91\u5B50\u6811\u8282\u70B9",
+  "node.editFailed": "\u8282\u70B9 {{name}} \u7F16\u8F91\u5931\u8D25",
+  "node.group": "\u8282\u70B9\u5206\u7EC4",
+  "node.groupNotEnabled": "\u8282\u70B9\u5206\u7EC4 \u201C{{group}}\u201D \u4EFB\u610F\u4E00\u4E2A\u672A\u5728\u5F53\u524D\u6587\u4EF6\u4E2D\u542F\u7528",
+  "node.id": "\u8282\u70B9\u6807\u8BC6",
+  "node.inputVariable": "\u8F93\u5165\u53D8\u91CF",
+  "node.invalidChildren": "\u5B50\u8282\u70B9\u6570\u91CF\u4E0D\u5408\u6CD5",
+  "node.invalidExpression": "\u8868\u8FBE\u5F0F\u4E0D\u5408\u6CD5",
+  "node.invalidValue": "\u65E0\u6548\u7684\u503C",
+  "node.invalidVariableName": "\u53D8\u91CF\u540D\u5FC5\u987B\u4EE5\u5B57\u6BCD\u6216\u4E0B\u5212\u7EBF\u5F00\u5934",
+  "node.name": "\u8282\u70B9\u540D\u79F0",
+  "node.noNodeSelected": "\u672A\u9009\u62E9\u4EFB\u52A1\u8282\u70B9",
+  "node.notFound": "\u8282\u70B9 \u201C{{name}}\u201D \u4E0D\u5B58\u5728",
+  "node.oneof.error": "\u8F93\u5165\u9879 \u201C{{input}}\u201D \u548C\u53C2\u6570 \u201C{{desc}}({{arg}})\u201D \u4E4B\u4E2D\uFF0C\u53EA\u80FD\u9009\u62E9\u8BBE\u7F6E\u5176\u4E2D\u4E4B\u4E00",
+  "node.oneof.inputNotfound": "\u8F93\u5165\u9879\u201C{{input}}\u201D\u4E0D\u5B58\u5728",
+  "node.outputVariable": "\u8F93\u51FA\u53D8\u91CF",
+  "node.pasteDataError": "\u7C98\u8D34\u6570\u636E\u51FA\u9519",
+  "node.rootNodeAsSubtree": "\u6839\u8282\u70B9\u4E0D\u80FD\u4FDD\u5B58\u4E3A\u5B50\u6811",
+  "node.subtree": "\u5B50\u6811",
+  "node.subtreeMissing": "\u5B50\u6811\u6587\u4EF6\u7F3A\u5931\uFF1A{{path}}",
+  "node.subtreeInvalid": "\u5B50\u6811\u6587\u4EF6\u65E0\u6548\uFF1A{{path}}",
+  "node.subtreeCyclic": "\u5B50\u6811\u5F15\u7528\u51FA\u73B0\u5FAA\u73AF\uFF1A{{path}}",
+  "node.subtreeOpenFailed": "\u6253\u5F00\u5B50\u6811\u5931\u8D25\uFF1A\u6587\u4EF6\u4E0D\u5B58\u5728\u6216\u4E0D\u53EF\u8BFB\uFF08{{path}}\uFF09",
+  "node.subtreePathError": "\u5B50\u6811\u5FC5\u987B\u4FDD\u5B58\u5728\u5F53\u524D\u5DE5\u4F5C\u533A\u7684\u76EE\u5F55\u5185",
+  "node.subtreeSaveRootError": "\u6839\u8282\u70B9\u4E0D\u80FD\u4FDD\u5B58\u4E3A\u5B50\u6811",
+  "node.subtreeSaveSuccess": "\u5DF2\u4FDD\u5B58\u5E76\u8F6C\u6362\u4E3A\u5B50\u6811\u8282\u70B9\uFF1A{{path}}",
+  "node.moveSubtreeDenied": "\u4E0D\u80FD\u79FB\u52A8\u5B50\u6811\u5185\u90E8\u8282\u70B9",
+  "node.dropSubtreeInternalDenied": "\u4E0D\u80FD\u62D6\u653E\u5230\u5B50\u6811\u5185\u90E8\u8282\u70B9",
+  "node.moveRootDenied": "\u4E0D\u80FD\u79FB\u52A8\u6839\u8282\u70B9",
+  "node.dropAroundRootDenied": "\u4E0D\u80FD\u5C06\u8282\u70B9\u653E\u5230\u6839\u8282\u70B9\u4E4B\u524D\u6216\u4E4B\u540E",
+  "node.addChildToSubtreeRefDenied": "\u4E0D\u80FD\u5411\u5B50\u6811\u5F15\u7528\u6DFB\u52A0\u5B50\u8282\u70B9",
+  "node.moveIntoDescendantDenied": "\u4E0D\u80FD\u5C06\u8282\u70B9\u79FB\u52A8\u5230\u81EA\u5DF1\u7684\u540E\u4EE3\u8282\u70B9\u4E2D",
+  "node.type": "\u8282\u70B9\u7C7B\u578B",
+  "node.undefinedVariable": "\u53D8\u91CF \u201C{{variable}}\u201D \u672A\u5B9A\u4E49",
+  "node.jsonData": "JSON \u6570\u636E",
+  "node.unknown.title": "\u672A\u77E5\u8282\u70B9",
+  "node.unknownType": "\u672A\u77E5",
+  "node.resolutionError": "\u89E3\u6790\u9519\u8BEF",
+  "node.unknown.desc": "\u65B0\u5EFA\u8282\u70B9",
+  "build.success": "\u6784\u5EFA\u5B8C\u6210\u3002",
+  "build.failed": "\u6784\u5EFA\u5931\u8D25\u3002",
+  "editor.loading": "\u6B63\u5728\u52A0\u8F7D\u7F16\u8F91\u5668...",
+  "editor.externalChangeConflict": "\u68C0\u6D4B\u5230\u5916\u90E8\u6587\u4EF6\u53D8\u66F4\uFF0C\u5F53\u524D\u6587\u6863\u8FD8\u6709\u672A\u4FDD\u5B58\u4FEE\u6539\u3002",
+  "editor.reloadFromDisk": "\u91CD\u65B0\u8F7D\u5165",
+  "editor.dismissConflict": "\u5FFD\u7565",
+  "editor.newerVersionEditDenied": "\u6B64\u6587\u4EF6\u7531\u65B0\u7248\u672C Behavior3({{version}}) \u521B\u5EFA\uFF0C\u8BF7\u5347\u7EA7\u5230\u6700\u65B0\u7248\u672C\u540E\u518D\u7F16\u8F91\u3002",
+  "inspector.noActiveDocument": "\u6253\u5F00\u4E00\u4E2A Behavior3 \u7F16\u8F91\u5668\u540E\uFF0C\u8FD9\u91CC\u4F1A\u663E\u793A\u5F53\u524D\u884C\u4E3A\u6811\u7684 Inspector\uFF0C\u5E76\u652F\u6301\u76F4\u63A5\u7F16\u8F91\u3002",
+  "inspector.embeddedModeNotice": "Inspector \u5F53\u524D\u914D\u7F6E\u4E3A\u5728 Behavior3 \u7F16\u8F91\u5668\u5185\u90E8\u663E\u793A\u3002",
+  "inspector.embeddedToolbar.build": "\u6784\u5EFA\u884C\u4E3A\u6811",
+  "inspector.embeddedToolbar.toggleEditorMode": "\u5207\u6362\u7F16\u8F91\u5668\u6A21\u5F0F",
+  "inspector.embeddedToolbar.toggleInspectorNodeJson": "\u5207\u6362\u539F\u59CB\u8282\u70B9 JSON",
+  "inspector.embeddedToolbar.createProject": "\u65B0\u5EFA\u9879\u76EE",
+  "inspector.embeddedToolbar.createTree": "\u65B0\u5EFA\u884C\u4E3A\u6811",
+  "mutation.invalidJsonPath": "\u65E0\u6548\u7684 JSON \u8DEF\u5F84: {{path}}",
+  "mutation.missingSelectedNode": "\u5F53\u524D\u6CA1\u6709\u53EF\u7528\u4E8E\u63D0\u4EA4\u6B64\u4FEE\u6539\u7684\u9009\u4E2D\u8282\u70B9\u3002",
+  "mutation.selectedNodeMismatch": "\u5F53\u524D\u9009\u4E2D\u8282\u70B9\u5DF2\u53D8\u5316\uFF0C\u8BF7\u91CD\u8BD5\u3002",
+  "mutation.missingTargetNode": "\u672A\u627E\u5230\u76EE\u6807\u8282\u70B9\uFF0C\u8BF7\u91CD\u8BD5\u3002",
+  "mutation.missingSourceNode": "\u672A\u627E\u5230\u6E90\u8282\u70B9\uFF0C\u8BF7\u91CD\u8BD5\u3002",
+  "mutation.missingSubtreeOriginal": "\u7F3A\u5C11 subtree \u539F\u59CB\u8282\u70B9\u5FEB\u7167\uFF0C\u8BF7\u91CD\u8BD5\u3002",
+  "mutation.missingDetachedSubtreeRoot": "\u7F3A\u5C11\u7528\u4E8E\u89E3\u7ED1 subtree \u5F15\u7528\u7684\u5FEB\u7167\uFF0C\u8BF7\u91CD\u8BD5\u3002",
+  "mutation.moveRootDenied": "\u4E0D\u80FD\u79FB\u52A8\u6839\u8282\u70B9\u3002",
+  "mutation.dropAroundRootDenied": "\u4E0D\u80FD\u56F4\u7ED5\u6839\u8282\u70B9\u63D2\u5165\u3002",
+  "mutation.addChildToSubtreeRefDenied": "\u4E0D\u80FD\u76F4\u63A5\u5411 subtree \u5F15\u7528\u6DFB\u52A0\u5B50\u8282\u70B9\u3002",
+  "mutation.moveIntoDescendantDenied": "\u4E0D\u80FD\u79FB\u52A8\u5230\u81EA\u5DF1\u7684\u540E\u4EE3\u4E0B\u3002",
+  "mutation.deleteRootNodeDenied": "\u4E0D\u80FD\u5220\u9664\u6839\u8282\u70B9\u3002",
+  "mutation.editSubtreeDenied": "\u4E0D\u80FD\u5728 subtree \u5F15\u7528\u4E0A\u76F4\u63A5\u4FEE\u6539\u7ED3\u6784\u3002",
+  "mutation.saveSelectedAsSubtreeRootDenied": "\u6839\u8282\u70B9\u4E0D\u80FD\u53E6\u5B58\u4E3A subtree\u3002",
+  "mutation.saveSelectedAsSubtreeMissingTarget": "\u672A\u627E\u5230\u53EF\u53E6\u5B58\u4E3A subtree \u7684\u76EE\u6807\u8282\u70B9\u3002",
+  "mutation.saveSelectedAsSubtreePostSaveMissingTarget": "\u63D0\u4EA4 subtree \u4FDD\u5B58\u7ED3\u679C\u65F6\u672A\u627E\u5230\u76EE\u6807\u8282\u70B9\u3002",
+  "runtime.nodeCheckRuntimeHasErrors": "checker \u8FD0\u884C\u65F6\u5B58\u5728\u9519\u8BEF\u3002",
+  "runtime.invalidSavedSubtreePath": "\u5BBF\u4E3B\u8FD4\u56DE\u4E86\u65E0\u6548\u7684 subtree \u4FDD\u5B58\u8DEF\u5F84\u3002",
+  "runtime.unsupportedDocumentMutation": "\u4E0D\u652F\u6301\u6B64\u6587\u6863\u4FEE\u6539\u3002",
+  "runtime.visibleHookNotRegistered": "visible \u201C{{name}}\u201D \u672A\u6CE8\u518C\u3002",
+  "runtime.visibleHookFailed": "visible \u201C{{name}}\u201D \u6267\u884C\u5931\u8D25\uFF1A{{error}}",
+  "runtime.visibleExpressionDisabled": "visible \u8868\u8FBE\u5F0F\u5DF2\u7981\u7528\uFF1B\u8BF7\u542F\u7528 settings.allowNewFunction\u3002",
+  "runtime.visibleExpressionCompileFailed": "visible \u8868\u8FBE\u5F0F\u7F16\u8BD1\u5931\u8D25\uFF1A{{error}}",
+  "runtime.visibleExpressionFailed": "visible \u8868\u8FBE\u5F0F\u6267\u884C\u5931\u8D25\uFF1A{{error}}",
+  "runtime.visibleExpressionUnknownArg": "visible \u8868\u8FBE\u5F0F\u5F15\u7528\u4E86 args.{{property}}\uFF0C\u4F46 \u201C{{property}}\u201D \u4E0D\u5728\u5DF2\u5B9A\u4E49\u7684\u53C2\u6570\u8303\u56F4\u5185\uFF08\u5DF2\u5B9A\u4E49\u53C2\u6570\uFF1A{{definedArgs}}\uFF09\u3002",
+  "runtime.visibleExpressionNoArgs": "visible \u8868\u8FBE\u5F0F\u5F15\u7528\u4E86 args.{{property}}\uFF0C\u4F46\u5F53\u524D\u8282\u70B9\u672A\u5B9A\u4E49\u53C2\u6570\u3002",
+  "runtime.visibleExpressionUnknownSlotIndex": "visible \u8868\u8FBE\u5F0F\u5F15\u7528\u4E86 {{fieldKind}}[{{index}}]\uFF0C\u4F46{{definedScope}}\u3002",
+  "runtime.visibleExpressionInvalidSlotProperty": "visible \u8868\u8FBE\u5F0F\u5F15\u7528\u4E86 {{fieldKind}}.{{property}}\uFF0C\u4F46 {{fieldKind}} \u4EC5\u652F\u6301\u5DF2\u5B9A\u4E49\u7684\u6570\u5B57\u69FD\u4F4D\u7D22\u5F15\u3002",
+  "runtime.visibleSlotScopeNone": "\u5F53\u524D\u8282\u70B9\u672A\u5B9A\u4E49{{fieldKind}}\u69FD\u4F4D",
+  "runtime.visibleSlotScopeIndex": "\u5DF2\u5B9A\u4E49\u7684{{fieldKind}}\u69FD\u4F4D\u7D22\u5F15\u53EA\u6709 {{start}}",
+  "runtime.visibleSlotScopeRange": "\u5DF2\u5B9A\u4E49\u7684{{fieldKind}}\u69FD\u4F4D\u7D22\u5F15\u8303\u56F4\u662F {{start}}..{{end}}",
+  "runtime.visibleSlotScopeRangeVariadic": "\u5DF2\u5B9A\u4E49\u7684{{fieldKind}}\u69FD\u4F4D\u7D22\u5F15\u8303\u56F4\u662F {{start}}..{{end}}+",
+  "override.resetTitle": "\u91CD\u7F6E\u6B64\u8986\u76D6\uFF1F",
+  "form.enterJsonArray": "\u8F93\u5165 JSON \u6570\u7EC4",
+  "form.enterJsonValue": "\u8F93\u5165 JSON \u503C",
+  "form.unset": "\u672A\u8BBE\u7F6E",
+  "form.true": "\u662F",
+  "form.false": "\u5426",
+  "validation.jsonArray": "{{name}} \u5FC5\u987B\u662F JSON \u6570\u7EC4",
+  "validation.integer": "{{field}} \u5FC5\u987B\u662F\u6574\u6570",
+  "validation.number": "{{field}} \u5FC5\u987B\u662F\u6570\u5B57",
+  "validation.missingOneofInput": "\u7F3A\u5C11 oneof \u8F93\u5165\u9879 \u201C{{input}}\u201D",
+  "validation.oneof": "\u201C{{left}}\u201D \u548C \u201C{{right}}\u201D \u53EA\u80FD\u8BBE\u7F6E\u5176\u4E2D\u4E4B\u4E00",
+  "validation.invalidJsonPath": "\u8DEF\u5F84\u5FC5\u987B\u662F\u5DE5\u4F5C\u76EE\u5F55\u5185\u7684\u76F8\u5BF9 .json \u6587\u4EF6\uFF1A{{path}}",
+  "validation.variableDescriptionRequired": "\u53D8\u91CF\u8BF4\u660E\u5FC5\u586B",
+  "validation.customKeyRequired": "\u81EA\u5B9A\u4E49 key \u5FC5\u586B",
+  "validation.customKeyDuplicate": "\u81EA\u5B9A\u4E49 key \u201C{{key}}\u201D \u91CD\u590D\u4E86",
+  "validation.customValueInvalid": "\u81EA\u5B9A\u4E49\u503C\u5FC5\u987B\u662F\u5B57\u7B26\u4E32\u3001\u6570\u5B57\u6216\u5E03\u5C14\u503C"
+};
+
+// webview/shared/runtime-i18n.ts
+var runtimeTranslations = {
+  en: en_default,
+  zh: zh_default
+};
+var INTERPOLATION_PATTERN = /\{\{\s*([^{}\s]+)\s*\}\}/g;
+var normalizeI18nLanguage = (language) => {
+  const value = (language ?? "").toLowerCase();
+  return value.startsWith("zh") ? "zh" : "en";
+};
+var interpolateRuntimeMessage = (template, params) => {
+  if (!params) {
+    return template;
+  }
+  return template.replace(INTERPOLATION_PATTERN, (match, key) => {
+    const value = params[key];
+    return value === void 0 || value === null ? match : String(value);
+  });
+};
+var translateRuntimeMessage = (language, key, params) => {
+  const template = runtimeTranslations[language][key] ?? runtimeTranslations.en[key] ?? key;
+  return interpolateRuntimeMessage(template, params);
+};
+
 // webview/shared/protocol.ts
 var URI_SCHEME_PATTERN = /^[a-zA-Z][a-zA-Z0-9+.-]*:/;
 var WINDOWS_ABSOLUTE_PATTERN = /^[a-zA-Z]:[\\/]/;
@@ -212881,6 +213348,7 @@ var normalizeWorkspaceModel = (value) => {
   }
   return {
     settings: {
+      allowNewFunction: typeof settingsRecord.allowNewFunction === "boolean" ? settingsRecord.allowNewFunction : void 0,
       checkExpr: typeof settingsRecord.checkExpr === "boolean" ? settingsRecord.checkExpr : void 0,
       buildScript: asOptionalString(settingsRecord.buildScript),
       checkScripts: settingsRecord.checkScripts === void 0 ? void 0 : Array.isArray(settingsRecord.checkScripts) ? settingsRecord.checkScripts.map(
@@ -213449,6 +213917,7 @@ var markVisibleHook = (nameOrCtor, _context) => {
 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
@@ -213480,6 +213949,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, env, reportMissing = true) => {
   if (!moduleExports || typeof moduleExports !== "object") {
     return void 0;
@@ -213565,6 +214035,342 @@ var createNodeFieldCheckers = (moduleExports, env) => {
   }
   return { checkers, hasError, hasCheckers: decorated.length > 0 };
 };
+var normalizeNodeFieldVisibleResult = (result) => result !== false;
+var VISIBLE_HANDLER_NAME_PATTERN = /^\w+$/;
+var VISIBLE_EXPRESSION_TOKEN_PATTERN = /[\s()[\].!=<>|&+*\/?:'"]/;
+var VISIBLE_ARRAY_INDEX_PATTERN = /^(0|[1-9]\d*)$/;
+var visibleExpressionCache = /* @__PURE__ */ new Map();
+var getBuildEnvLanguage = (env) => normalizeI18nLanguage(env.language);
+var translateVisibleRuntimeMessage = (env, key, params) => translateRuntimeMessage(getBuildEnvLanguage(env), key, params);
+var formatVisibleArgScope = (env, definedArgNames) => getBuildEnvLanguage(env) === "zh" ? definedArgNames.join("\u3001") : definedArgNames.join(", ");
+var getVisibleFieldKindLabel = (env, fieldKind) => {
+  if (getBuildEnvLanguage(env) === "zh") {
+    return fieldKind === "input" ? "\u8F93\u5165" : "\u8F93\u51FA";
+  }
+  return fieldKind;
+};
+var parseVisibleArrayIndex = (property) => {
+  if (typeof property === "number") {
+    return Number.isInteger(property) && property >= 0 ? property : null;
+  }
+  if (typeof property === "string" && VISIBLE_ARRAY_INDEX_PATTERN.test(property)) {
+    return Number(property);
+  }
+  return null;
+};
+var isVisibleSlotIndexDefined = (slotDefs, index) => {
+  if (index < 0) {
+    return false;
+  }
+  const slotCount = slotDefs?.length ?? 0;
+  if (slotCount === 0) {
+    return false;
+  }
+  if (index < slotCount) {
+    return true;
+  }
+  const normalizedSlotDefs = slotDefs ?? [];
+  return parseSlotDefinition(
+    normalizedSlotDefs[slotCount - 1] ?? "",
+    normalizedSlotDefs,
+    slotCount - 1
+  ).variadic;
+};
+var formatVisibleSlotScope = (env, fieldKind, slotDefs) => {
+  const slotCount = slotDefs?.length ?? 0;
+  const fieldKindLabel = getVisibleFieldKindLabel(env, fieldKind);
+  if (slotCount === 0) {
+    return translateVisibleRuntimeMessage(env, "runtime.visibleSlotScopeNone", {
+      fieldKind: fieldKindLabel
+    });
+  }
+  if (parseSlotDefinition(slotDefs?.[slotCount - 1] ?? "", slotDefs, slotCount - 1).variadic) {
+    return translateVisibleRuntimeMessage(env, "runtime.visibleSlotScopeRangeVariadic", {
+      fieldKind: fieldKindLabel,
+      start: 0,
+      end: slotCount - 1
+    });
+  }
+  return slotCount === 1 ? translateVisibleRuntimeMessage(env, "runtime.visibleSlotScopeIndex", {
+    fieldKind: fieldKindLabel,
+    start: 0
+  }) : translateVisibleRuntimeMessage(env, "runtime.visibleSlotScopeRange", {
+    fieldKind: fieldKindLabel,
+    start: 0,
+    end: slotCount - 1
+  });
+};
+var createVisibleArgScope = (ctx) => {
+  const definedArgNames = (ctx.nodeDef.args ?? []).map((arg) => arg.name);
+  const definedArgNameSet = new Set(definedArgNames);
+  const target = Object.assign(
+    /* @__PURE__ */ Object.create(null),
+    ctx.node.args ?? {}
+  );
+  return new Proxy(target, {
+    get(currentTarget, property) {
+      if (typeof property === "symbol") {
+        return Reflect.get(currentTarget, property);
+      }
+      if (definedArgNameSet.has(property)) {
+        return currentTarget[property];
+      }
+      throw new Error(
+        definedArgNames.length ? translateVisibleRuntimeMessage(
+          ctx.env,
+          "runtime.visibleExpressionUnknownArg",
+          {
+            property,
+            definedArgs: formatVisibleArgScope(ctx.env, definedArgNames)
+          }
+        ) : translateVisibleRuntimeMessage(ctx.env, "runtime.visibleExpressionNoArgs", {
+          property
+        })
+      );
+    },
+    has(_currentTarget, property) {
+      if (typeof property === "symbol") {
+        return false;
+      }
+      return definedArgNameSet.has(property);
+    }
+  });
+};
+var createVisibleSlotScope = (fieldKind, values, slotDefs, env) => {
+  const target = values ?? [];
+  return new Proxy(target, {
+    get(currentTarget, property, receiver) {
+      if (typeof property === "symbol") {
+        return Reflect.get(currentTarget, property, receiver);
+      }
+      const index = parseVisibleArrayIndex(property);
+      if (index !== null) {
+        if (!isVisibleSlotIndexDefined(slotDefs, index)) {
+          throw new Error(
+            translateVisibleRuntimeMessage(
+              env,
+              "runtime.visibleExpressionUnknownSlotIndex",
+              {
+                fieldKind: getVisibleFieldKindLabel(env, fieldKind),
+                index,
+                definedScope: formatVisibleSlotScope(env, fieldKind, slotDefs)
+              }
+            )
+          );
+        }
+        return Reflect.get(currentTarget, property, receiver);
+      }
+      if (property in currentTarget || property in Array.prototype) {
+        return Reflect.get(currentTarget, property, receiver);
+      }
+      throw new Error(
+        translateVisibleRuntimeMessage(
+          env,
+          "runtime.visibleExpressionInvalidSlotProperty",
+          {
+            fieldKind: getVisibleFieldKindLabel(env, fieldKind),
+            property: String(property)
+          }
+        )
+      );
+    },
+    has(currentTarget, property) {
+      if (typeof property === "symbol") {
+        return property in currentTarget;
+      }
+      const index = parseVisibleArrayIndex(property);
+      if (index !== null) {
+        return isVisibleSlotIndexDefined(slotDefs, index);
+      }
+      return property in currentTarget || property in Array.prototype;
+    }
+  });
+};
+var isNamedNodeFieldVisible = (visibleName) => VISIBLE_HANDLER_NAME_PATTERN.test(visibleName);
+var isInlineNodeFieldVisibleExpression = (visibleName, visibles) => {
+  if (visibles.has(visibleName)) {
+    return false;
+  }
+  if (isNamedNodeFieldVisible(visibleName)) {
+    return false;
+  }
+  return VISIBLE_EXPRESSION_TOKEN_PATTERN.test(visibleName);
+};
+var getVisibleExpressionEvaluator = (expression) => {
+  const cached = visibleExpressionCache.get(expression);
+  if (cached) {
+    return cached;
+  }
+  const evaluator = new Function(
+    "args",
+    "input",
+    "output",
+    "value",
+    `"use strict"; return (${expression});`
+  );
+  visibleExpressionCache.set(expression, evaluator);
+  return evaluator;
+};
+var resolveNodeFieldVisible = (params) => {
+  if (!isInlineNodeFieldVisibleExpression(params.visibleName, params.visibles)) {
+    const visible = params.visibles.get(params.visibleName);
+    if (!visible) {
+      return {
+        diagnostic: {
+          source: params.visibleName,
+          message: translateVisibleRuntimeMessage(
+            params.ctx.env,
+            "runtime.visibleHookNotRegistered",
+            {
+              name: params.visibleName
+            }
+          )
+        }
+      };
+    }
+    try {
+      return {
+        visible: normalizeNodeFieldVisibleResult(visible.visible(params.value, params.ctx))
+      };
+    } catch (error) {
+      return {
+        diagnostic: {
+          source: params.visibleName,
+          message: translateVisibleRuntimeMessage(
+            params.ctx.env,
+            "runtime.visibleHookFailed",
+            {
+              name: params.visibleName,
+              error: formatRuntimeError(error)
+            }
+          )
+        }
+      };
+    }
+  }
+  if (!params.ctx.env.allowNewFunction) {
+    return {
+      diagnostic: {
+        source: params.visibleName,
+        message: translateVisibleRuntimeMessage(
+          params.ctx.env,
+          "runtime.visibleExpressionDisabled"
+        )
+      }
+    };
+  }
+  let evaluator;
+  try {
+    evaluator = getVisibleExpressionEvaluator(params.visibleName);
+  } catch (error) {
+    return {
+      diagnostic: {
+        source: params.visibleName,
+        message: translateVisibleRuntimeMessage(
+          params.ctx.env,
+          "runtime.visibleExpressionCompileFailed",
+          {
+            error: formatRuntimeError(error)
+          }
+        )
+      }
+    };
+  }
+  try {
+    return {
+      visible: normalizeNodeFieldVisibleResult(
+        evaluator(
+          createVisibleArgScope(params.ctx),
+          createVisibleSlotScope(
+            "input",
+            params.ctx.node.input ?? [],
+            params.ctx.nodeDef.input,
+            params.ctx.env
+          ),
+          createVisibleSlotScope(
+            "output",
+            params.ctx.node.output ?? [],
+            params.ctx.nodeDef.output,
+            params.ctx.env
+          ),
+          params.value
+        )
+      )
+    };
+  } catch (error) {
+    return {
+      diagnostic: {
+        source: params.visibleName,
+        message: translateVisibleRuntimeMessage(
+          params.ctx.env,
+          "runtime.visibleExpressionFailed",
+          {
+            error: formatRuntimeError(error)
+          }
+        )
+      }
+    };
+  }
+};
+var createNodeFieldVisibles = (moduleExports, env) => {
+  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(env);
+      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, env) => {
+  const nodeFieldVisibles = /* @__PURE__ */ new Map();
+  let hasError = false;
+  const mergeModuleVisibles = (moduleExports) => {
+    const visibleResult = createNodeFieldVisibles(moduleExports, env);
+    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, env) => {
   if (!moduleExports || typeof moduleExports !== "object") {
     return {
@@ -213889,38 +214695,49 @@ var collectNodeFieldCheckDiagnostics = (params) => {
       nodeDef,
       treePath: target.treePath ?? params.treePath,
       env: params.env,
-      onArg: ({ fieldName, checkerName, value, ctx }) => {
-        if (!checkerName) {
-          return;
-        }
-        const pushDiagnostic = (message) => {
+      onArg: ({ fieldName, checkerName, visibleName, value, ctx }) => {
+        const pushDiagnostic = (source, message) => {
           diagnostics.push({
             instanceKey: target.instanceKey,
             nodeId: node.id,
             nodeName: node.name,
             fieldKind: "arg",
             fieldName,
-            checker: checkerName,
+            checker: source,
             message
           });
         };
+        if (visibleName) {
+          const resolution = resolveNodeFieldVisible({
+            visibleName,
+            value,
+            ctx,
+            visibles: params.visibles ?? /* @__PURE__ */ new Map()
+          });
+          if (resolution.diagnostic) {
+            pushDiagnostic(resolution.diagnostic.source, resolution.diagnostic.message);
+          }
+        }
+        if (!checkerName) {
+          return;
+        }
         const checker = params.checkers.get(checkerName);
         if (!checker) {
-          pushDiagnostic(`checker '${checkerName}' is not registered`);
+          pushDiagnostic(checkerName, `checker '${checkerName}' is not registered`);
           return;
         }
         try {
           const messages = normalizeNodeFieldCheckResult(checker.validate(value, ctx));
-          messages.forEach(pushDiagnostic);
+          messages.forEach((message) => pushDiagnostic(checkerName, message));
         } catch (error) {
-          pushDiagnostic(`checker '${checkerName}' failed: ${formatRuntimeError(error)}`);
+          pushDiagnostic(
+            checkerName,
+            `checker '${checkerName}' failed: ${formatRuntimeError(error)}`
+          );
         }
       },
-      onInput: ({ fieldName, fieldIndex, checkerName, value, ctx }) => {
-        if (!checkerName) {
-          return;
-        }
-        const pushDiagnostic = (message) => {
+      onInput: ({ fieldName, fieldIndex, checkerName, visibleName, value, ctx }) => {
+        const pushDiagnostic = (source, message) => {
           diagnostics.push({
             instanceKey: target.instanceKey,
             nodeId: node.id,
@@ -213928,27 +214745,41 @@ var collectNodeFieldCheckDiagnostics = (params) => {
             fieldKind: "input",
             fieldName,
             fieldIndex,
-            checker: checkerName,
+            checker: source,
             message
           });
         };
+        if (visibleName) {
+          const resolution = resolveNodeFieldVisible({
+            visibleName,
+            value,
+            ctx,
+            visibles: params.visibles ?? /* @__PURE__ */ new Map()
+          });
+          if (resolution.diagnostic) {
+            pushDiagnostic(resolution.diagnostic.source, resolution.diagnostic.message);
+          }
+        }
+        if (!checkerName) {
+          return;
+        }
         const checker = params.checkers.get(checkerName);
         if (!checker) {
-          pushDiagnostic(`checker '${checkerName}' is not registered`);
+          pushDiagnostic(checkerName, `checker '${checkerName}' is not registered`);
           return;
         }
         try {
           const messages = normalizeNodeFieldCheckResult(checker.validate(value, ctx));
-          messages.forEach(pushDiagnostic);
+          messages.forEach((message) => pushDiagnostic(checkerName, message));
         } catch (error) {
-          pushDiagnostic(`checker '${checkerName}' failed: ${formatRuntimeError(error)}`);
+          pushDiagnostic(
+            checkerName,
+            `checker '${checkerName}' failed: ${formatRuntimeError(error)}`
+          );
         }
       },
-      onOutput: ({ fieldName, fieldIndex, checkerName, value, ctx }) => {
-        if (!checkerName) {
-          return;
-        }
-        const pushDiagnostic = (message) => {
+      onOutput: ({ fieldName, fieldIndex, checkerName, visibleName, value, ctx }) => {
+        const pushDiagnostic = (source, message) => {
           diagnostics.push({
             instanceKey: target.instanceKey,
             nodeId: node.id,
@@ -213956,20 +214787,37 @@ var collectNodeFieldCheckDiagnostics = (params) => {
             fieldKind: "output",
             fieldName,
             fieldIndex,
-            checker: checkerName,
+            checker: source,
             message
           });
         };
+        if (visibleName) {
+          const resolution = resolveNodeFieldVisible({
+            visibleName,
+            value,
+            ctx,
+            visibles: params.visibles ?? /* @__PURE__ */ new Map()
+          });
+          if (resolution.diagnostic) {
+            pushDiagnostic(resolution.diagnostic.source, resolution.diagnostic.message);
+          }
+        }
+        if (!checkerName) {
+          return;
+        }
         const checker = params.checkers.get(checkerName);
         if (!checker) {
-          pushDiagnostic(`checker '${checkerName}' is not registered`);
+          pushDiagnostic(checkerName, `checker '${checkerName}' is not registered`);
           return;
         }
         try {
           const messages = normalizeNodeFieldCheckResult(checker.validate(value, ctx));
-          messages.forEach(pushDiagnostic);
+          messages.forEach((message) => pushDiagnostic(checkerName, message));
         } catch (error) {
-          pushDiagnostic(`checker '${checkerName}' failed: ${formatRuntimeError(error)}`);
+          pushDiagnostic(
+            checkerName,
+            `checker '${checkerName}' failed: ${formatRuntimeError(error)}`
+          );
         }
       }
     });
@@ -214406,13 +215254,19 @@ var buildProjectWithContext = async (project, buildDir, context) => {
     path: b3path_default,
     workdir: context.workdir,
     nodeDefs: context.nodeDefs,
-    logger
+    logger,
+    allowNewFunction: settings.allowNewFunction ?? false
   };
   const buildRuntime = createBuildScriptRuntimeWithCheckModules(
     buildScriptModule,
     checkScriptModules,
     scriptEnv
   );
+  const visibleRuntime = createNodeFieldVisibleRuntimeWithCheckModules(
+    buildScriptModule,
+    checkScriptModules,
+    scriptEnv
+  );
   if (buildSetting && (!buildScriptModule || buildRuntime.hasError)) {
     hasError = true;
   }
@@ -214458,7 +215312,8 @@ var buildProjectWithContext = async (project, buildDir, context) => {
       tree,
       treePath: candidatePath,
       env: scriptEnv,
-      checkers: buildRuntime.nodeFieldCheckers
+      checkers: buildRuntime.nodeFieldCheckers,
+      visibles: visibleRuntime.nodeFieldVisibles
     });
     if (checkDiagnostics.length) {
       hasError = true;
@@ -214491,6 +215346,7 @@ var batchProcessProjectWithContext = async (project, scriptPath, context) => {
   let writtenFiles = 0;
   const allErrors = [];
   const stagedWrites = [];
+  const settings = readWorkspaceSettings(project);
   let buildScriptModule;
   try {
     buildScriptModule = await loadRuntimeModule(scriptPath, {
@@ -214504,7 +215360,8 @@ var batchProcessProjectWithContext = async (project, scriptPath, context) => {
     path: b3path_default,
     workdir: context.workdir,
     nodeDefs: context.nodeDefs,
-    logger
+    logger,
+    allowNewFunction: settings.allowNewFunction ?? false
   };
   const buildScript = createBatchHooks(buildScriptModule, scriptEnv);
   if (!buildScriptModule || !buildScript) {