@redue/cli 0.1.0-alpha.3 → 0.1.0-alpha.31

package/src/pnpm-shim-templates.json

@@ -0,0 +1,180 @@
+{
+ "schema": 1,
+ "templates": [
+  {
+   "versions": [
+    "8.0.0",
+    "8.1.1",
+    "8.2.0",
+    "8.3.1",
+    "8.4.0",
+    "8.5.1",
+    "8.6.12",
+    "8.7.6",
+    "8.8.0",
+    "8.9.2",
+    "8.10.5",
+    "8.11.0",
+    "8.12.1",
+    "8.13.1",
+    "8.14.3",
+    "8.15.9",
+    "9.0.6",
+    "9.1.4",
+    "9.2.0",
+    "9.3.0",
+    "9.4.0",
+    "9.5.0",
+    "9.6.0",
+    "9.7.1",
+    "9.8.0",
+    "9.9.0",
+    "9.10.0",
+    "9.11.0",
+    "9.12.3",
+    "9.13.2",
+    "9.14.4",
+    "9.15.4",
+    "9.15.9",
+    "10.0.0",
+    "10.1.0",
+    "10.2.1",
+    "10.3.0",
+    "10.4.1",
+    "10.5.2",
+    "10.6.5",
+    "10.7.1",
+    "10.8.1",
+    "10.9.0"
+   ],
+   "template": "#!/bin/sh\nbasedir=$(dirname \"$(echo \"$0\" | sed -e 's,\\\\,/,g')\")\n\ncase `uname` in\n    *CYGWIN*) basedir=`cygpath -w \"$basedir\"`;;\nesac\n\nif [ -z \"$NODE_PATH\" ]; then\n  export NODE_PATH=\"@@NODE_PATH@@\"\nelse\n  export NODE_PATH=\"@@NODE_PATH@@:$NODE_PATH\"\nfi\nif [ -x \"$basedir/node\" ]; then\n  exec \"$basedir/node\"  \"$basedir/@@TARGET@@\" \"$@\"\nelse\n  exec node  \"$basedir/@@TARGET@@\" \"$@\"\nfi\n"
+  },
+  {
+   "versions": [
+    "10.10.0",
+    "10.11.1",
+    "10.12.4",
+    "10.13.1",
+    "10.14.0",
+    "10.15.1",
+    "10.16.1",
+    "10.17.1",
+    "10.18.3",
+    "10.19.0",
+    "10.20.0",
+    "10.21.0",
+    "10.22.0",
+    "10.23.0",
+    "10.24.0",
+    "10.25.0",
+    "10.26.2",
+    "10.27.0",
+    "10.28.2",
+    "10.29.3",
+    "10.30.3",
+    "10.31.0",
+    "10.32.1",
+    "10.33.2",
+    "10.33.4",
+    "10.34.7"
+   ],
+   "template": "#!/bin/sh\nbasedir=$(dirname \"$(echo \"$0\" | sed -e 's,\\\\,/,g')\")\n\ncase `uname` in\n    *CYGWIN*|*MINGW*|*MSYS*)\n        if command -v cygpath > /dev/null 2>&1; then\n            basedir=`cygpath -w \"$basedir\"`\n        fi\n    ;;\nesac\n\nif [ -z \"$NODE_PATH\" ]; then\n  export NODE_PATH=\"@@NODE_PATH@@\"\nelse\n  export NODE_PATH=\"@@NODE_PATH@@:$NODE_PATH\"\nfi\nif [ -x \"$basedir/node\" ]; then\n  exec \"$basedir/node\"  \"$basedir/@@TARGET@@\" \"$@\"\nelse\n  exec node  \"$basedir/@@TARGET@@\" \"$@\"\nfi\n"
+  },
+  {
+   "versions": [
+    "11.0.9",
+    "11.1.1",
+    "11.1.3",
+    "11.2.2",
+    "11.3.0",
+    "11.4.0",
+    "11.5.3",
+    "11.6.0"
+   ],
+   "template": "#!/bin/sh\nbasedir=$(dirname \"$(echo \"$0\" | sed -e 's,\\\\,/,g')\")\n\ncase `uname` in\n    *CYGWIN*|*MINGW*|*MSYS*)\n        if command -v cygpath > /dev/null 2>&1; then\n            basedir=`cygpath -w \"$basedir\"`\n        fi\n    ;;\nesac\n\nif [ -z \"$NODE_PATH\" ]; then\n  export NODE_PATH=\"@@NODE_PATH@@\"\nelse\n  export NODE_PATH=\"@@NODE_PATH@@:$NODE_PATH\"\nfi\nif [ -x \"$basedir/node\" ]; then\n  exec \"$basedir/node\"  \"$basedir/@@TARGET@@\" \"$@\"\nelse\n  exec node  \"$basedir/@@TARGET@@\" \"$@\"\nfi\n# cmd-shim-target=@@COMMENT@@\n"
+  },
+  {
+   "versions": [
+    "11.7.0",
+    "11.8.0",
+    "11.9.0",
+    "11.10.0",
+    "11.11.0",
+    "11.12.0",
+    "11.13.1",
+    "11.14.0",
+    "11.15.1",
+    "11.16.0",
+    "11.17.0",
+    "11.18.0",
+    "11.19.0",
+    "11.20.0"
+   ],
+   "template": "#!/bin/sh\nbasedir=$(dirname \"$(echo \"$0\" | sed -e 's,\\\\,/,g')\")\nbasedir_win=\"$basedir\"\nexe=\"\"\nmsys=\"\"\n\ncase `uname -a` in\n  *CYGWIN*|*MINGW*|*MSYS*)\n    if command -v cygpath > /dev/null 2>&1; then\n      basedir_win=`cygpath -w \"$basedir\"`\n    fi\n    exe=\".exe\"\n    msys=\"true\"\n  ;;\n  *WSL2*)\n    if command -v wslpath > /dev/null 2>&1; then\n      basedir_win=\"$(wslpath -w \"$basedir\" 2> /dev/null)\"\n      if [ $? -ne 0 ] || [ -z \"$basedir_win\" ]; then\n        basedir_win=\"$basedir\"\n      else\n        exe=\".exe\"\n      fi\n    fi\n  ;;\nesac\n\nif [ -z \"$NODE_PATH\" ]; then\n  export NODE_PATH=\"@@NODE_PATH@@\"\nelse\n  export NODE_PATH=\"@@NODE_PATH@@:$NODE_PATH\"\nfi\nif [ -n \"$exe\" ] && [ -x \"$basedir/node.exe\" ]; then\n  exec \"$basedir/node.exe\"  \"$basedir_win/@@TARGET@@\" \"$@\"\nelif [ -x \"$basedir/node\" ]; then\n  exec \"$basedir/node\"  \"$basedir/@@TARGET@@\" \"$@\"\nelif command -v node >/dev/null 2>&1; then\n  exec node  \"$basedir/@@TARGET@@\" \"$@\"\nelif [ -n \"$exe\" ] && command -v node.exe >/dev/null 2>&1; then\n  exec node.exe  \"$basedir_win/@@TARGET@@\" \"$@\"\nelse\n  exec node  \"$basedir/@@TARGET@@\" \"$@\"\nfi\n# cmd-shim-target=@@COMMENT@@\n"
+  },
+  {
+   "versions": [
+    "11.21.0",
+    "11.22.0",
+    "11.23.0",
+    "11.24.0",
+    "11.25.0",
+    "11.26.0",
+    "12.0.0",
+    "12.1.0",
+    "12.2.1",
+    "12.3.4"
+   ],
+   "template": "#!/bin/sh\n# Resolve $0 through symlinks so basedir is the shim's real directory.\n# Cap hops at the kernel's ELOOP limit so a cycle cannot hang the shim.\nlink=\"$0\"\nhops=0\nwhile [ -L \"$link\" ] && [ \"$hops\" -lt 40 ]; do\n  hops=$((hops+1))\n  target=$(readlink \"$link\")\n  case \"$target\" in\n    /*) link=\"$target\" ;;\n    *)  link=\"$(dirname \"$link\")/$target\" ;;\n  esac\ndone\nbasedir=$(dirname \"$(echo \"$link\" | sed -e 's,\\\\,/,g')\")\nbasedir_win=\"$basedir\"\nexe=\"\"\nmsys=\"\"\n\ncase `uname -a` in\n  *CYGWIN*|*MINGW*|*MSYS*)\n    if command -v cygpath > /dev/null 2>&1; then\n      basedir_win=`cygpath -w \"$basedir\"`\n    fi\n    exe=\".exe\"\n    msys=\"true\"\n  ;;\n  *WSL2*)\n    if command -v wslpath > /dev/null 2>&1; then\n      basedir_win=\"$(wslpath -w \"$basedir\" 2> /dev/null)\"\n      if [ $? -ne 0 ] || [ -z \"$basedir_win\" ]; then\n        basedir_win=\"$basedir\"\n      else\n        exe=\".exe\"\n      fi\n    fi\n  ;;\nesac\n\nif [ -z \"$NODE_PATH\" ]; then\n  export NODE_PATH=\"@@NODE_PATH@@\"\nelse\n  export NODE_PATH=\"@@NODE_PATH@@:$NODE_PATH\"\nfi\nif [ -n \"$exe\" ] && [ -x \"$basedir/node.exe\" ]; then\n  exec \"$basedir/node.exe\"  \"$basedir_win/@@TARGET@@\" \"$@\"\nelif [ -x \"$basedir/node\" ]; then\n  exec \"$basedir/node\"  \"$basedir/@@TARGET@@\" \"$@\"\nelif command -v node >/dev/null 2>&1; then\n  exec node  \"$basedir/@@TARGET@@\" \"$@\"\nelif [ -n \"$exe\" ] && command -v node.exe >/dev/null 2>&1; then\n  exec node.exe  \"$basedir_win/@@TARGET@@\" \"$@\"\nelse\n  exec node  \"$basedir/@@TARGET@@\" \"$@\"\nfi\n# cmd-shim-target=@@COMMENT@@\n"
+  },
+  {
+   "versions": [
+    "11.27.1"
+   ],
+   "template": "#!/bin/sh\n# Resolve $0 through symlinks so basedir is the shim's real directory.\n# Cap hops at the kernel's ELOOP limit so a cycle cannot hang the shim.\n#\n# A shim runs with node_modules/.bin at the front of PATH, so readlink, sed,\n# uname, and printf go through `command -p`, which searches the system default\n# path instead. A dependency's bin cannot stand in for one of them and take over\n# the shim before it reaches its target. Directories come from `${link%/*}`,\n# which needs no helper at all.\nlink=\"$0\"\n# `${link%/*}` needs a separator to strip. A bare name came from a PATH lookup\n# and stands for a file in the current directory.\ncase \"$link\" in\n  */*|*\\\\*) ;;\n  *) link=\"./$link\" ;;\nesac\nhops=0\nwhile [ -L \"$link\" ] && [ \"$hops\" -lt 40 ]; do\n  hops=$((hops+1))\n  target=$(command -p readlink \"$link\")\n  case \"$target\" in\n    /*) link=\"$target\" ;;\n    *)  link=\"${link%/*}/$target\" ;;\n  esac\ndone\nbasedir=$(command -p printf '%s\\n' \"$link\" | command -p sed -e 's,\\\\,/,g')\nbasedir=\"${basedir%/*}\"\nbasedir_win=\"$basedir\"\nexe=\"\"\nmsys=\"\"\n\ncase `command -p uname -a` in\n  *CYGWIN*|*MINGW*|*MSYS*)\n    if converted=$(command -p cygpath -w \"$basedir\" 2>/dev/null) && [ -n \"$converted\" ]; then\n      basedir_win=\"$converted\"\n    elif command -v cygpath > /dev/null 2>&1; then\n      basedir_win=`cygpath -w \"$basedir\"`\n    fi\n    exe=\".exe\"\n    msys=\"true\"\n  ;;\n  *WSL2*)\n    if converted=$(command -p wslpath -w \"$basedir\" 2>/dev/null) && [ -n \"$converted\" ]; then\n      basedir_win=\"$converted\"\n      exe=\".exe\"\n    elif command -v wslpath > /dev/null 2>&1; then\n      basedir_win=\"$(wslpath -w \"$basedir\" 2> /dev/null)\"\n      if [ $? -ne 0 ] || [ -z \"$basedir_win\" ]; then\n        basedir_win=\"$basedir\"\n      else\n        exe=\".exe\"\n      fi\n    fi\n  ;;\nesac\n\nif [ -z \"$NODE_PATH\" ]; then\n  export NODE_PATH=\"@@NODE_PATH@@\"\nelse\n  export NODE_PATH=\"@@NODE_PATH@@:$NODE_PATH\"\nfi\nif [ -n \"$exe\" ] && [ -x \"$basedir/node.exe\" ]; then\n  exec \"$basedir/node.exe\"  \"$basedir_win/@@TARGET@@\" \"$@\"\nelif [ -x \"$basedir/node\" ]; then\n  exec \"$basedir/node\"  \"$basedir/@@TARGET@@\" \"$@\"\nelif command -v node >/dev/null 2>&1; then\n  exec node  \"$basedir/@@TARGET@@\" \"$@\"\nelif [ -n \"$exe\" ] && command -v node.exe >/dev/null 2>&1; then\n  exec node.exe  \"$basedir_win/@@TARGET@@\" \"$@\"\nelse\n  exec node  \"$basedir/@@TARGET@@\" \"$@\"\nfi\n# cmd-shim-target=@@COMMENT@@\n"
+  },
+  {
+   "versions": [
+    "11.28.2"
+   ],
+   "template": "#!/bin/sh\n# Resolve $0 through symlinks so basedir is the shim's real directory.\n# Cap hops at the kernel's ELOOP limit so a cycle cannot hang the shim.\n#\n# A shim runs with node_modules/.bin at the front of PATH, so readlink, sed,\n# uname, and printf go through `command -p`, which searches the system default\n# path instead. A dependency's bin cannot stand in for one of them and take over\n# the shim before it reaches its target. Directories come from `${link%/*}`,\n# which needs no helper at all.\n#\n# Where no default path is compiled in, as on Nix, `command -p` searches PATH\n# instead, so the helpers run with node_modules and relative entries dropped from\n# PATH.\ncaller_path_set=${PATH+set}\ncaller_path=${PATH-}\nhelper_path=\nrest=$caller_path:\nwhile [ -n \"$rest\" ]; do\n  dir=${rest%%:*}\n  rest=${rest#*:}\n  case \"$dir\" in\n    */node_modules/*|*/node_modules) ;;\n    /*) helper_path=${helper_path:+$helper_path:}$dir ;;\n  esac\ndone\n# An empty PATH searches the current directory.\nPATH=${helper_path:-/}\nlink=\"$0\"\n# `${link%/*}` needs a separator to strip. A bare name came from a PATH lookup\n# and stands for a file in the current directory.\ncase \"$link\" in\n  */*|*\\\\*) ;;\n  *) link=\"./$link\" ;;\nesac\nhops=0\nwhile [ -L \"$link\" ] && [ \"$hops\" -lt 40 ]; do\n  hops=$((hops+1))\n  target=$(command -p readlink \"$link\")\n  case \"$target\" in\n    /*) link=\"$target\" ;;\n    *)  link=\"${link%/*}/$target\" ;;\n  esac\ndone\nbasedir=$(command -p printf '%s\\n' \"$link\" | command -p sed -e 's,\\\\,/,g')\nbasedir=\"${basedir%/*}\"\nbasedir_abs=$(CDPATH= cd -P -- \"$basedir\" && pwd -P) || exit $?\nbasedir=\"$basedir_abs\"\nbasedir_win=\"$basedir\"\nexe=\"\"\nmsys=\"\"\n\ncase `command -p uname -a` in\n  *CYGWIN*|*MINGW*|*MSYS*)\n    if converted=$(command -p cygpath -w \"$basedir\" 2>/dev/null) && [ -n \"$converted\" ]; then\n      basedir_win=\"$converted\"\n    elif command -v cygpath > /dev/null 2>&1; then\n      basedir_win=`cygpath -w \"$basedir\"`\n    fi\n    exe=\".exe\"\n    msys=\"true\"\n  ;;\n  *WSL2*)\n    if converted=$(command -p wslpath -w \"$basedir\" 2>/dev/null) && [ -n \"$converted\" ]; then\n      basedir_win=\"$converted\"\n      exe=\".exe\"\n    elif command -v wslpath > /dev/null 2>&1; then\n      basedir_win=\"$(wslpath -w \"$basedir\" 2> /dev/null)\"\n      if [ $? -ne 0 ] || [ -z \"$basedir_win\" ]; then\n        basedir_win=\"$basedir\"\n      else\n        exe=\".exe\"\n      fi\n    fi\n  ;;\nesac\nif [ -n \"$caller_path_set\" ]; then PATH=$caller_path; else unset PATH; fi\n\nif [ -z \"$NODE_PATH\" ]; then\n  export NODE_PATH=\"@@NODE_PATH@@\"\nelse\n  export NODE_PATH=\"@@NODE_PATH@@:$NODE_PATH\"\nfi\nif [ -n \"$exe\" ] && [ -x \"$basedir/node.exe\" ]; then\n  exec \"$basedir/node.exe\"  \"$basedir_win/@@TARGET@@\" \"$@\"\nelif [ -x \"$basedir/node\" ]; then\n  exec \"$basedir/node\"  \"$basedir_abs/@@TARGET@@\" \"$@\"\nelif [ -n \"$msys\" ] && command -v node >/dev/null 2>&1; then\n  exec node  \"$basedir_win/@@TARGET@@\" \"$@\"\nelif command -v node >/dev/null 2>&1; then\n  exec node  \"$basedir_abs/@@TARGET@@\" \"$@\"\nelif [ -n \"$exe\" ] && command -v node.exe >/dev/null 2>&1; then\n  exec node.exe  \"$basedir_win/@@TARGET@@\" \"$@\"\nelse\n  exec node  \"$basedir_abs/@@TARGET@@\" \"$@\"\nfi\n# cmd-shim-target=@@COMMENT@@\n"
+  },
+  {
+   "versions": [
+    "11.28.6",
+    "12.8.2",
+    "12.9.1",
+    "12.10.1",
+    "12.11.2",
+    "12.12.1",
+    "12.13.0",
+    "12.14.0"
+   ],
+   "template": "#!/bin/sh\n# Resolve $0 through symlinks so basedir is the shim's real directory.\n# Cap hops at the kernel's ELOOP limit so a cycle cannot hang the shim.\n#\n# A shim runs with node_modules/.bin at the front of PATH, so readlink, sed,\n# uname, and printf go through `command -p`, which searches the system default\n# path instead. A dependency's bin cannot stand in for one of them and take over\n# the shim before it reaches its target. Directories come from `${link%/*}`,\n# which needs no helper at all.\n#\n# A helper the default path lacks, as in a Nix build sandbox, comes from PATH\n# instead, with node_modules and relative entries dropped from it.\ncaller_path_set=${PATH+set}\ncaller_path=${PATH-}\nhelper_path=\nrest=$caller_path:\nwhile [ -n \"$rest\" ]; do\n  dir=${rest%%:*}\n  rest=${rest#*:}\n  case \"$dir\" in\n    */node_modules/*|*/node_modules) ;;\n    /*) helper_path=${helper_path:+$helper_path:}$dir ;;\n  esac\ndone\n# An empty PATH searches the current directory.\nPATH=${helper_path:-/}\n# A helper comes from PATH only when the default path lacks it and PATH has it.\n# The bash 3.2 that macOS ships as sh answers `command -p -v` from PATH.\nrun_helper() {\n  if command -p -v \"$1\" >/dev/null 2>&1 || ! command -v \"$1\" >/dev/null 2>&1; then command -p \"$@\"; else command \"$@\"; fi\n}\nlink=\"$0\"\n# `${link%/*}` needs a separator to strip. A bare name came from a PATH lookup\n# and stands for a file in the current directory.\ncase \"$link\" in\n  */*|*\\\\*) ;;\n  *) link=\"./$link\" ;;\nesac\nhops=0\nwhile [ -L \"$link\" ] && [ \"$hops\" -lt 40 ]; do\n  hops=$((hops+1))\n  target=$(run_helper readlink \"$link\")\n  case \"$target\" in\n    /*) link=\"$target\" ;;\n    *)  link=\"${link%/*}/$target\" ;;\n  esac\ndone\nbasedir=$(run_helper printf '%s\\n' \"$link\" | run_helper sed -e 's,\\\\,/,g')\nbasedir=\"${basedir%/*}\"\nbasedir_abs=$(CDPATH= cd -P -- \"$basedir\" && pwd -P) || exit $?\nbasedir=\"$basedir_abs\"\nbasedir_win=\"$basedir\"\nexe=\"\"\nmsys=\"\"\n\ncase `run_helper uname -a` in\n  *CYGWIN*|*MINGW*|*MSYS*)\n    if converted=$(command -p cygpath -w \"$basedir\" 2>/dev/null) && [ -n \"$converted\" ]; then\n      basedir_win=\"$converted\"\n    elif command -v cygpath > /dev/null 2>&1; then\n      basedir_win=`cygpath -w \"$basedir\"`\n    fi\n    exe=\".exe\"\n    msys=\"true\"\n  ;;\n  *WSL2*)\n    if converted=$(command -p wslpath -w \"$basedir\" 2>/dev/null) && [ -n \"$converted\" ]; then\n      basedir_win=\"$converted\"\n      exe=\".exe\"\n    elif command -v wslpath > /dev/null 2>&1; then\n      basedir_win=\"$(wslpath -w \"$basedir\" 2> /dev/null)\"\n      if [ $? -ne 0 ] || [ -z \"$basedir_win\" ]; then\n        basedir_win=\"$basedir\"\n      else\n        exe=\".exe\"\n      fi\n    fi\n  ;;\nesac\nif [ -n \"$caller_path_set\" ]; then PATH=$caller_path; else unset PATH; fi\n\nif [ -z \"$NODE_PATH\" ]; then\n  export NODE_PATH=\"@@NODE_PATH@@\"\nelse\n  export NODE_PATH=\"@@NODE_PATH@@:$NODE_PATH\"\nfi\nif [ -n \"$exe\" ] && [ -x \"$basedir/node.exe\" ]; then\n  exec \"$basedir/node.exe\"  \"$basedir_win/@@TARGET@@\" \"$@\"\nelif [ -x \"$basedir/node\" ]; then\n  exec \"$basedir/node\"  \"$basedir_abs/@@TARGET@@\" \"$@\"\nelif [ -n \"$msys\" ] && command -v node >/dev/null 2>&1; then\n  exec node  \"$basedir_win/@@TARGET@@\" \"$@\"\nelif command -v node >/dev/null 2>&1; then\n  exec node  \"$basedir_abs/@@TARGET@@\" \"$@\"\nelif [ -n \"$exe\" ] && command -v node.exe >/dev/null 2>&1; then\n  exec node.exe  \"$basedir_win/@@TARGET@@\" \"$@\"\nelse\n  exec node  \"$basedir_abs/@@TARGET@@\" \"$@\"\nfi\n# cmd-shim-target=@@COMMENT@@\n"
+  },
+  {
+   "versions": [
+    "12.4.2"
+   ],
+   "template": "#!/bin/sh\n# Resolve $0 through symlinks so basedir is the shim's real directory.\n# Cap hops at the kernel's ELOOP limit so a cycle cannot hang the shim.\n#\n# A shim runs with node_modules/.bin at the front of PATH, so readlink, sed, and\n# uname go through `command -p`, which searches the system default path instead.\n# A dependency's bin cannot stand in for one of them and take over the shim\n# before it reaches its target. Directories come from `${link%/*}`, which needs\n# no helper at all.\nlink=\"$0\"\n# `${link%/*}` needs a separator to strip. A bare name came from a PATH lookup\n# and stands for a file in the current directory.\ncase \"$link\" in\n  */*|*\\\\*) ;;\n  *) link=\"./$link\" ;;\nesac\nhops=0\nwhile [ -L \"$link\" ] && [ \"$hops\" -lt 40 ]; do\n  hops=$((hops+1))\n  target=$(command -p readlink \"$link\")\n  case \"$target\" in\n    /*) link=\"$target\" ;;\n    *)  link=\"${link%/*}/$target\" ;;\n  esac\ndone\nbasedir=$(echo \"$link\" | command -p sed -e 's,\\\\,/,g')\nbasedir=\"${basedir%/*}\"\nbasedir_win=\"$basedir\"\nexe=\"\"\nmsys=\"\"\n\ncase `command -p uname -a` in\n  *CYGWIN*|*MINGW*|*MSYS*)\n    if command -v cygpath > /dev/null 2>&1; then\n      basedir_win=`cygpath -w \"$basedir\"`\n    fi\n    exe=\".exe\"\n    msys=\"true\"\n  ;;\n  *WSL2*)\n    if command -v wslpath > /dev/null 2>&1; then\n      basedir_win=\"$(wslpath -w \"$basedir\" 2> /dev/null)\"\n      if [ $? -ne 0 ] || [ -z \"$basedir_win\" ]; then\n        basedir_win=\"$basedir\"\n      else\n        exe=\".exe\"\n      fi\n    fi\n  ;;\nesac\n\nif [ -z \"$NODE_PATH\" ]; then\n  export NODE_PATH=\"@@NODE_PATH@@\"\nelse\n  export NODE_PATH=\"@@NODE_PATH@@:$NODE_PATH\"\nfi\nif [ -n \"$exe\" ] && [ -x \"$basedir/node.exe\" ]; then\n  exec \"$basedir/node.exe\"  \"$basedir_win/@@TARGET@@\" \"$@\"\nelif [ -x \"$basedir/node\" ]; then\n  exec \"$basedir/node\"  \"$basedir/@@TARGET@@\" \"$@\"\nelif command -v node >/dev/null 2>&1; then\n  exec node  \"$basedir/@@TARGET@@\" \"$@\"\nelif [ -n \"$exe\" ] && command -v node.exe >/dev/null 2>&1; then\n  exec node.exe  \"$basedir_win/@@TARGET@@\" \"$@\"\nelse\n  exec node  \"$basedir/@@TARGET@@\" \"$@\"\nfi\n# cmd-shim-target=@@COMMENT@@\n"
+  },
+  {
+   "versions": [
+    "12.5.1"
+   ],
+   "template": "#!/bin/sh\n# Resolve $0 through symlinks so basedir is the shim's real directory.\n# Cap hops at the kernel's ELOOP limit so a cycle cannot hang the shim.\n#\n# A shim runs with node_modules/.bin at the front of PATH, so readlink, sed,\n# uname, and printf go through `command -p`, which searches the system default\n# path instead. A dependency's bin cannot stand in for one of them and take over\n# the shim before it reaches its target. Directories come from `${link%/*}`,\n# which needs no helper at all.\nlink=\"$0\"\n# `${link%/*}` needs a separator to strip. A bare name came from a PATH lookup\n# and stands for a file in the current directory.\ncase \"$link\" in\n  */*|*\\\\*) ;;\n  *) link=\"./$link\" ;;\nesac\nhops=0\nwhile [ -L \"$link\" ] && [ \"$hops\" -lt 40 ]; do\n  hops=$((hops+1))\n  target=$(command -p readlink \"$link\")\n  case \"$target\" in\n    /*) link=\"$target\" ;;\n    *)  link=\"${link%/*}/$target\" ;;\n  esac\ndone\nbasedir=$(command -p printf '%s\\n' \"$link\" | command -p sed -e 's,\\\\,/,g')\nbasedir=\"${basedir%/*}\"\nbasedir_win=\"$basedir\"\nexe=\"\"\nmsys=\"\"\n\ncase `command -p uname -a` in\n  *CYGWIN*|*MINGW*|*MSYS*)\n    if command -v cygpath > /dev/null 2>&1; then\n      basedir_win=`cygpath -w \"$basedir\"`\n    fi\n    exe=\".exe\"\n    msys=\"true\"\n  ;;\n  *WSL2*)\n    if command -v wslpath > /dev/null 2>&1; then\n      basedir_win=\"$(wslpath -w \"$basedir\" 2> /dev/null)\"\n      if [ $? -ne 0 ] || [ -z \"$basedir_win\" ]; then\n        basedir_win=\"$basedir\"\n      else\n        exe=\".exe\"\n      fi\n    fi\n  ;;\nesac\n\nif [ -z \"$NODE_PATH\" ]; then\n  export NODE_PATH=\"@@NODE_PATH@@\"\nelse\n  export NODE_PATH=\"@@NODE_PATH@@:$NODE_PATH\"\nfi\nif [ -n \"$exe\" ] && [ -x \"$basedir/node.exe\" ]; then\n  exec \"$basedir/node.exe\"  \"$basedir_win/@@TARGET@@\" \"$@\"\nelif [ -x \"$basedir/node\" ]; then\n  exec \"$basedir/node\"  \"$basedir/@@TARGET@@\" \"$@\"\nelif command -v node >/dev/null 2>&1; then\n  exec node  \"$basedir/@@TARGET@@\" \"$@\"\nelif [ -n \"$exe\" ] && command -v node.exe >/dev/null 2>&1; then\n  exec node.exe  \"$basedir_win/@@TARGET@@\" \"$@\"\nelse\n  exec node  \"$basedir/@@TARGET@@\" \"$@\"\nfi\n# cmd-shim-target=@@COMMENT@@\n"
+  },
+  {
+   "versions": [
+    "12.6.0"
+   ],
+   "template": "#!/bin/sh\n# Resolve $0 through symlinks so basedir is the shim's real directory.\n# Cap hops at the kernel's ELOOP limit so a cycle cannot hang the shim.\n#\n# A shim runs with node_modules/.bin at the front of PATH, so readlink, sed,\n# uname, and printf go through `command -p`, which searches the system default\n# path instead. A dependency's bin cannot stand in for one of them and take over\n# the shim before it reaches its target. Directories come from `${link%/*}`,\n# which needs no helper at all.\nlink=\"$0\"\n# `${link%/*}` needs a separator to strip. A bare name came from a PATH lookup\n# and stands for a file in the current directory.\ncase \"$link\" in\n  */*|*\\\\*) ;;\n  *) link=\"./$link\" ;;\nesac\nhops=0\nwhile [ -L \"$link\" ] && [ \"$hops\" -lt 40 ]; do\n  hops=$((hops+1))\n  target=$(command -p readlink \"$link\")\n  case \"$target\" in\n    /*) link=\"$target\" ;;\n    *)  link=\"${link%/*}/$target\" ;;\n  esac\ndone\nbasedir=$(command -p printf '%s\\n' \"$link\" | command -p sed -e 's,\\\\,/,g')\nbasedir=\"${basedir%/*}\"\nbasedir_win=\"$basedir\"\nexe=\"\"\nmsys=\"\"\n\ncase `command -p uname -a` in\n  *CYGWIN*|*MINGW*|*MSYS*)\n    if converted=$(command -p cygpath -w \"$basedir\" 2>/dev/null) && [ -n \"$converted\" ]; then\n      basedir_win=\"$converted\"\n    elif command -v cygpath > /dev/null 2>&1; then\n      basedir_win=`cygpath -w \"$basedir\"`\n    fi\n    exe=\".exe\"\n    msys=\"true\"\n  ;;\n  *WSL2*)\n    if converted=$(command -p wslpath -w \"$basedir\" 2>/dev/null) && [ -n \"$converted\" ]; then\n      basedir_win=\"$converted\"\n      exe=\".exe\"\n    elif command -v wslpath > /dev/null 2>&1; then\n      basedir_win=\"$(wslpath -w \"$basedir\" 2> /dev/null)\"\n      if [ $? -ne 0 ] || [ -z \"$basedir_win\" ]; then\n        basedir_win=\"$basedir\"\n      else\n        exe=\".exe\"\n      fi\n    fi\n  ;;\nesac\n\nbasedir_abs=$(CDPATH= cd -P -- \"$basedir\" && pwd -P) || exit $?\nif [ -z \"$NODE_PATH\" ]; then\n  export NODE_PATH=\"@@NODE_PATH@@\"\nelse\n  export NODE_PATH=\"@@NODE_PATH@@:$NODE_PATH\"\nfi\nif [ -n \"$exe\" ] && [ -x \"$basedir/node.exe\" ]; then\n  exec \"$basedir/node.exe\"  \"$basedir_win/@@TARGET@@\" \"$@\"\nelif [ -x \"$basedir/node\" ]; then\n  exec \"$basedir/node\"  \"$basedir_abs/@@TARGET@@\" \"$@\"\nelif command -v node >/dev/null 2>&1; then\n  exec node  \"$basedir_abs/@@TARGET@@\" \"$@\"\nelif [ -n \"$exe\" ] && command -v node.exe >/dev/null 2>&1; then\n  exec node.exe  \"$basedir_win/@@TARGET@@\" \"$@\"\nelse\n  exec node  \"$basedir_abs/@@TARGET@@\" \"$@\"\nfi\n# cmd-shim-target=@@COMMENT@@\n"
+  },
+  {
+   "versions": [
+    "12.7.0"
+   ],
+   "template": "#!/bin/sh\n# Resolve $0 through symlinks so basedir is the shim's real directory.\n# Cap hops at the kernel's ELOOP limit so a cycle cannot hang the shim.\n#\n# A shim runs with node_modules/.bin at the front of PATH, so readlink, sed,\n# uname, and printf go through `command -p`, which searches the system default\n# path instead. A dependency's bin cannot stand in for one of them and take over\n# the shim before it reaches its target. Directories come from `${link%/*}`,\n# which needs no helper at all.\n#\n# Where no default path is compiled in, as on Nix, `command -p` searches PATH\n# instead, so the helpers run with node_modules and relative entries dropped from\n# PATH.\ncaller_path_set=${PATH+set}\ncaller_path=${PATH-}\nhelper_path=\nrest=$caller_path:\nwhile [ -n \"$rest\" ]; do\n  dir=${rest%%:*}\n  rest=${rest#*:}\n  case \"$dir\" in\n    */node_modules/*|*/node_modules) ;;\n    /*) helper_path=${helper_path:+$helper_path:}$dir ;;\n  esac\ndone\n# An empty PATH searches the current directory.\nPATH=${helper_path:-/}\nlink=\"$0\"\n# `${link%/*}` needs a separator to strip. A bare name came from a PATH lookup\n# and stands for a file in the current directory.\ncase \"$link\" in\n  */*|*\\\\*) ;;\n  *) link=\"./$link\" ;;\nesac\nhops=0\nwhile [ -L \"$link\" ] && [ \"$hops\" -lt 40 ]; do\n  hops=$((hops+1))\n  target=$(command -p readlink \"$link\")\n  case \"$target\" in\n    /*) link=\"$target\" ;;\n    *)  link=\"${link%/*}/$target\" ;;\n  esac\ndone\nbasedir=$(command -p printf '%s\\n' \"$link\" | command -p sed -e 's,\\\\,/,g')\nbasedir=\"${basedir%/*}\"\nbasedir_win=\"$basedir\"\nexe=\"\"\nmsys=\"\"\n\ncase `command -p uname -a` in\n  *CYGWIN*|*MINGW*|*MSYS*)\n    if converted=$(command -p cygpath -w \"$basedir\" 2>/dev/null) && [ -n \"$converted\" ]; then\n      basedir_win=\"$converted\"\n    elif command -v cygpath > /dev/null 2>&1; then\n      basedir_win=`cygpath -w \"$basedir\"`\n    fi\n    exe=\".exe\"\n    msys=\"true\"\n  ;;\n  *WSL2*)\n    if converted=$(command -p wslpath -w \"$basedir\" 2>/dev/null) && [ -n \"$converted\" ]; then\n      basedir_win=\"$converted\"\n      exe=\".exe\"\n    elif command -v wslpath > /dev/null 2>&1; then\n      basedir_win=\"$(wslpath -w \"$basedir\" 2> /dev/null)\"\n      if [ $? -ne 0 ] || [ -z \"$basedir_win\" ]; then\n        basedir_win=\"$basedir\"\n      else\n        exe=\".exe\"\n      fi\n    fi\n  ;;\nesac\nif [ -n \"$caller_path_set\" ]; then PATH=$caller_path; else unset PATH; fi\n\nbasedir_abs=$(CDPATH= cd -P -- \"$basedir\" && pwd -P) || exit $?\nif [ -z \"$NODE_PATH\" ]; then\n  export NODE_PATH=\"@@NODE_PATH@@\"\nelse\n  export NODE_PATH=\"@@NODE_PATH@@:$NODE_PATH\"\nfi\nif [ -n \"$exe\" ] && [ -x \"$basedir/node.exe\" ]; then\n  exec \"$basedir/node.exe\"  \"$basedir_win/@@TARGET@@\" \"$@\"\nelif [ -x \"$basedir/node\" ]; then\n  exec \"$basedir/node\"  \"$basedir_abs/@@TARGET@@\" \"$@\"\nelif command -v node >/dev/null 2>&1; then\n  exec node  \"$basedir_abs/@@TARGET@@\" \"$@\"\nelif [ -n \"$exe\" ] && command -v node.exe >/dev/null 2>&1; then\n  exec node.exe  \"$basedir_win/@@TARGET@@\" \"$@\"\nelse\n  exec node  \"$basedir_abs/@@TARGET@@\" \"$@\"\nfi\n# cmd-shim-target=@@COMMENT@@\n"
+  }
+ ]
+}

package/src/pnpm-shims.mjs

@@ -0,0 +1,54 @@
+// pnpm's launchers. On macOS and Linux, pnpm writes each node_modules/.bin
+// entry as a `#!/bin/sh` script that finds its own directory (with sed,
+// dirname, readlink, uname or printf, depending on the pnpm release), sets
+// NODE_PATH and execs Node on the package's bin file. A launcher is trusted only
+// when its text is one of the templates pnpm releases write
+// (pnpm-shim-templates.json, built by eval/pnpm-shim-templates.mjs), with only
+// the NODE_PATH value, the bin file and the trailing target comment filled in.
+import fs from 'node:fs';
+import path from 'node:path';
+
+const templates=JSON.parse(fs.readFileSync(new URL('pnpm-shim-templates.json',import.meta.url),'utf8')).templates;
+const known=new Set(templates.map(row=>row.template));
+// A value with no quote, expansion, escape or line break: it stays literal in
+// the shell.
+const literal=/^[^"$`\\\n]*$/;
+
+// The launcher's text as a template, with the values it fills in, or null
+// when it does not have pnpm's form.
+export function shimTemplate(text){
+  if(typeof text!=='string'||!text.startsWith('#!/bin/sh\n'))return null;
+  let template=text,nodePath=null;
+  // NODE_PATH, set alone or in front of the caller's.
+  const alone=/\n  export NODE_PATH="([^"\n]*)"\n/.exec(text);
+  if(alone){
+    nodePath=alone[1];
+    // Each entry is literal, or relative to the launcher's own directory
+    // ($basedir_abs, which pnpm 12.6 and later write).
+    if(!nodePath.split(':').every(entry=>literal.test(entry.replace(/^\$basedir(?:_abs)?\//,'')))||
+      !text.includes(`\n  export NODE_PATH="${nodePath}:$NODE_PATH"\n`))return null;
+    template=template.split(`\n  export NODE_PATH="${nodePath}:$NODE_PATH"\n`).join('\n  export NODE_PATH="@@NODE_PATH@@:$NODE_PATH"\n')
+      .split(`\n  export NODE_PATH="${nodePath}"\n`).join('\n  export NODE_PATH="@@NODE_PATH@@"\n');
+  }
+  // The bin file, relative to the launcher's directory, after $basedir,
+  // $basedir_abs or $basedir_win; `node` and `node.exe` there are Node itself.
+  const targets=new Set([...template.matchAll(/"\$basedir(?:_abs|_win)?\/([^"\n]+)"/g)].map(match=>match[1])
+    .filter(value=>value!=='node'&&value!=='node.exe'));
+  if(targets.size!==1)return null;
+  const [target]=targets;
+  if(!literal.test(target))return null;
+  for(const prefix of ['$basedir','$basedir_abs','$basedir_win'])
+    template=template.split(`"${prefix}/${target}"`).join(`"${prefix}/@@TARGET@@"`);
+  // pnpm 11 and later end with a comment naming the target.
+  template=template.replace(/\n# cmd-shim-target=[^\n]*\n?$/,'\n# cmd-shim-target=@@COMMENT@@\n');
+  return {template,nodePath,target};
+}
+// The bin file a pnpm launcher runs with Node, as an absolute path, or null
+// when `file` is not a launcher pnpm writes.
+export function pnpmShimTarget(file,text=null){
+  try{
+    text??=fs.readFileSync(file,'utf8');
+    const shim=shimTemplate(text);
+    return shim&&known.has(shim.template)?path.resolve(path.dirname(file),shim.target):null;
+  }catch{return null;}
+}

package/src/pnpm-typecheck-probe.mjs

@@ -7,14 +7,17 @@ import fs from 'node:fs';
 import path from 'node:path';
 import {createHash} from 'node:crypto';
 import {pnpmTypecheckInputs} from './pnpm-inputs.mjs';
+import {patternMatcher} from './glob.mjs';
 import {withinPath as within,realObservedPath} from './path-identity.mjs';
+import {runFromArgv} from './typescript-invocation.mjs';
 
-const [rootArg,workspace,script]=process.argv.slice(2);
+const [rootArg,workspace,...rest]=process.argv.slice(2).filter(value=>!value.startsWith('--redue-'));
 const hash=value=>createHash('sha256').update(value).digest('hex');
 const digest=file=>hash(fs.readFileSync(file));
 const fail=code=>{throw Object.assign(Error(code),{code});};
 try{
-  if(!rootArg||!workspace||!script)fail('probe-arguments');
+  if(!rootArg||!workspace)fail('probe-arguments');
+  const run=runFromArgv(rest);
   const root=realObservedPath(rootArg);
   if(process.env.NODE_OPTIONS||process.env.NODE_PATH||process.env.BASH_ENV||
     process.env.ENV||Object.entries(process.env).some(([key,value])=>{
@@ -24,23 +27,25 @@ try{
       return /^(PNPM_|COREPACK_|npm_config_|DYLD_|TSGO_)/i.test(key);
     }))
     fail('pnpm-execution-environment-unsupported');
-  const contextHash=hash(JSON.stringify([root,workspace,script,process.version]));
+  const contextHash=hash(JSON.stringify([root,workspace,run,process.version]));
   if(contextOnly(contextHash))process.exit(0);
-  const contract=pnpmTypecheckInputs(root,workspace,script,{captureQueries:process.argv.includes('--redue-checkpoint')});
+  const contract=pnpmTypecheckInputs(root,workspace,run,{captureQueries:process.argv.includes('--redue-checkpoint')});
   if(contract.limitations.length)fail('pnpm-input-coverage-unavailable');
   const selected=path.join(root,contract.workspace.dir),tsc=contract.tsc;
   const inputs=contract.listedFiles;
   if(!inputs.length)fail('typescript-input-list-unavailable');
-  const inputRoots=[path.join(selected,'src'),...contract.generated.map(pattern=>
+  const inputRoots=[...contract.generated.map(pattern=>
     path.join(root,pattern.slice(0,-3))),...contract.installed.filter(p=>!p.startsWith('!'))
       .map(pattern=>path.join(root,pattern.slice(0,-3)))];
+  const isSource=patternMatcher(contract.sourcePatterns);
   for(const file of inputs)if(!within(file,root)||
+    !isSource(path.relative(root,file).split(path.sep).join('/'))&&
     !inputRoots.some(boundary=>within(file,boundary)))
     fail('typescript-input-outside-pnpm-contract');
   const files=[...new Set(inputs)].sort().map(file=>
     [hash(path.relative(root,file)),digest(file)]);
   const configs=contract.configs.map(file=>[hash(file),digest(path.join(root,file))]);
-  probeResult(hash(JSON.stringify({schema:1,workspace,script,
+  probeResult(hash(JSON.stringify({schema:1,workspace,run,
     files,configs,node:process.version,tsc:digest(tsc),
     packageManager:contract.install.version,linker:contract.install.linker})),contextHash,contract.discoveryQueries);
 }catch(e){console.error(`VSTATE_REASON:${e.code&&/^[a-z-]+$/.test(e.code)?e.code:

package/src/presentation.mjs

@@ -1,4 +1,10 @@
 // Presentation consumes evidence; it never grants applicability.
+// The recipe that made a receipt, by the qualification it names.
+const recipes={'npm-typescript-direct-v1':'direct TypeScript recipe','npm-tests-direct-v1':'direct test recipe',
+  'node-script-v1':'general recipe','pnpm-tsc-v1':'pnpm TypeScript recipe','yarn-workspace-tsc-v1':'Yarn workspace TypeScript recipe',
+  'typescript-noemit-v1':'npm TypeScript recipe','sandbox-v1':'sandboxed recipe',
+  'sandbox-v2':'sandboxed recipe, git-ignored files hidden','sandbox-v3':'sandboxed recipe, git-ignored files and docs hidden'};
+export const recipeLabel=recipe=>recipes[recipe]??null;
 export function checkLabel(row) {
   return row.result==='FAIL'?'FAILED':row.freshness;
 }
@@ -6,8 +12,8 @@ export function explanation(row) {
   const reason=row.reason||'No verification evidence is available.';
   if(reason==='no receipt')return 'No execution has been recorded. Run this check when verification is needed.';
   if(reason==='declared inputs match')return 'Recorded evidence still applies to the declared inputs.';
-  if(reason==='execution environment context not supplied')return 'Cached status cannot confirm your execution context. Use --sync if worthwhile, or rerun the check.';
-  if(/requires? a synchronized content read/.test(reason))return 'Cached status cannot establish applicability here. Use --sync if worthwhile, or rerun the check.';
+  if(reason==='execution environment context not supplied')return 'Cached status cannot confirm your execution context. Run redue status without --cached, or rerun the check.';
+  if(/requires? a synchronized content read/.test(reason))return 'Cached status cannot establish applicability here. Run redue status without --cached, or rerun the check.';
   if(reason.startsWith('input coverage unresolved: '))return 'Recording-only: '+reason.slice(27);
   if(/input plan (rebuilding|indexing)|observer initialization|input observation reconciliation pending/.test(reason))
     return 'Checking inputs after startup or changes. Wait for observation to finish, then query again.';
@@ -21,7 +27,8 @@ export function renderStatus(value,{short=false}={}) {
     const label=checkLabel(row),symbol=label==='CURRENT'&&row.result==='PASS'?'✓':label==='FAILED'?'✗':'?';
     const mark=label==='STALE'?'⚠':symbol;
     const historical=row.result?` / ${row.result}`:'';
-    lines.push(`${mark} ${row.name}  ${label}${historical}`);
+    const recipe=label==='CURRENT'?recipeLabel(row.recipe):null;
+    lines.push(`${mark} ${row.name}  ${label}${historical}${recipe?`  (${recipe})`:''}`);
     if(label!=='CURRENT')lines.push(`  ${row.result==='FAIL'?`Historical failure; applicability ${row.freshness}. `:''}${explanation(row)}`);
   }
   if(!lines.length)lines.push('UNVERIFIED — observation is initializing; no check state is available yet.');
@@ -33,6 +40,8 @@ export function renderExplain(value,name) {
   return rows.map(row=>{
     const lines=[`${row.name}: ${checkLabel(row)}${row.result?` / ${row.result}`:''}`];
     if(row.result==='FAIL')lines.push(`Historical failure; applicability: ${row.freshness}.`);
+    if(row.verification_recipe==='npm-direct-typescript@1')lines.push('Recorded recipe: direct local TypeScript compiler; npm and lifecycle scripts were not executed.');
+    else if(recipeLabel(row.recipe))lines.push(`Recorded recipe: ${recipeLabel(row.recipe)}.`);
     lines.push(explanation(row));
     if(row.changed_inputs?.length)lines.push('Relevant inputs changed:',...row.changed_inputs.map(file=>`  ${file}`));
     if(row.freshness==='STALE')lines.push(`Due again when verification is needed: redue run ${JSON.stringify(row.name)}`);
@@ -47,6 +56,6 @@ export function renderRun(value) {
   if(value.invocation!=='exited')lines.push(`Invocation ${value.invocation}; no reusable passing evidence.`);
   else if(!value.coverage_qualified)lines.push('Applicability remains UNVERIFIED: input coverage is incomplete.');
   else if(!value.stable)lines.push('Applicability remains UNVERIFIED: inputs changed or observation was unavailable during execution.');
-  else lines.push('Inspect redue status before reusing this evidence. Cached status may require --sync to establish applicability.');
+  else lines.push('Check redue status before reusing this evidence.');
   return lines.join('\n');
 }

package/src/probe-deadline.mjs

@@ -0,0 +1,37 @@
+// How long a full probe may run before it is killed and the check stays
+// UNVERIFIED. It grows with the project: the larger of the hint from earlier
+// probes (twice the last successful one, or twice the deadline that last timed
+// out) and the last completed run, between the platform floor and a ceiling.
+import {fileURLToPath} from 'node:url';
+export const probeCeilingMs=process.env.VSTATE_TEST_FAULTS==='1'&&
+  Number(process.env.VSTATE_TEST_PROBE_CEILING_MS)||60000;
+// Supported TypeScript probes perform bounded input/toolchain hashing.
+// Native NTFS runs have exceeded the generic 5 s cap under load, despite
+// completing normally and with the duplicated work already removed.
+export const probeFloorMs=qualification=>qualification==='pnpm-tsc-v1'||
+  (process.platform==='win32'&&['typescript-noemit-v1','npm-typescript-direct-v1','yarn-workspace-tsc-v1']
+    .includes(qualification))?10000:5000;
+// REDUE's own probes, which accept --redue-deadline; a user's probe never gets it.
+const builtIn=new Set(['typescript-contract-probe.mjs','direct-typescript-probe.mjs',
+  'yarn-workspace-typecheck-probe.mjs','pnpm-typecheck-probe.mjs'].map(name=>fileURLToPath(new URL(name,import.meta.url))));
+export const builtInProbe=argv=>builtIn.has(argv?.[1]);
+// A deadline read from status.json, as a whole number of milliseconds no
+// longer than a decision could need (0 when absent or unusable).
+export function publishedDeadline(value) {
+  return Number.isFinite(value)&&value>0?Math.min(Math.round(value),10*60*1000):0;
+}
+export function probeDeadline({floor,hint=0,runMs=0,ceiling=probeCeilingMs}) {
+  const finite=value=>Number.isFinite(value)&&value>0?value:0;
+  return Math.round(Math.min(ceiling,Math.max(floor,finite(hint),finite(runMs))));
+}
+// The hint the next probe starts from.
+export function nextProbeHint({durationMs,deadlineMs,timedOut}) {
+  return 2*(timedOut?deadlineMs:durationMs);
+}
+// Inside a probe process: what is left of the deadline its caller passed with
+// --redue-deadline=MS, or the fallback when none was passed. An inner call
+// always ends before its parent is killed, so it never outlives the probe.
+export function probeTimeLeft(fallback) {
+  const deadline=Number(/^--redue-deadline=(\d+)$/.exec(process.argv.find(arg=>arg.startsWith('--redue-deadline='))||'')?.[1]);
+  return deadline?Math.max(1,Math.round(deadline-performance.now()-250)):fallback;
+}

package/src/probe-result.mjs

@@ -9,11 +9,15 @@ export function contextOnly(context) {
   }
   return false;
 }
-export function probeResult(output,context,queries=null) {
+// A layout lets a recorded run rebuild the output after a content-only edit.
+export function probeResult(output,context,queries=null,layout=null) {
   if(!process.argv.includes('--redue-checkpoint')){process.stdout.write(output);return;}
   const raw=queries?JSON.stringify(queries):null;
-  let value=JSON.stringify({output,context,queryData:raw&&Buffer.byteLength(raw)<=8*1024*1024?
-    deflateSync(raw).toString('base64'):null});
+  const queryData=raw&&Buffer.byteLength(raw)<=8*1024*1024?deflateSync(raw).toString('base64'):null;
+  let value=JSON.stringify({output,context,queryData,
+    ...(layout?{layoutData:deflateSync(JSON.stringify(layout)).toString('base64')}:{})});
+  // The layout is dropped first: it only shortens the run after an edit.
+  if(Buffer.byteLength(value)>512*1024)value=JSON.stringify({output,context,queryData});
   // Optimization metadata must not overflow the ordinary probe channel.
   // Larger contracts keep the normal complete probe, without result reuse.
   if(Buffer.byteLength(value)>512*1024)value=JSON.stringify({output,context,queries:null});

package/src/project-location.mjs

@@ -0,0 +1,34 @@
+// Shared project selection only; evidence and caller-context semantics stay in the kernel.
+import fs from 'node:fs';
+import path from 'node:path';
+import os from 'node:os';
+import {createHash} from 'node:crypto';
+import {realObservedPath} from './path-identity.mjs';
+import {stateIdentity,userStateBase} from './platform-state.mjs';
+
+export function discoverConfig(cwd=process.cwd()) {
+  let dir=path.resolve(cwd);const found=[];
+  for(;;){
+    for(const name of ['redue.config.json','vstate.config.json']) {
+      const file=path.join(dir,name);
+      if(fs.existsSync(file))found.push(file);
+    }
+    if(fs.existsSync(path.join(dir,'.git'))||path.dirname(dir)===dir)break;
+    dir=path.dirname(dir);
+  }
+  if(found.length>1)throw Error('multiple REDUE configurations apply; select the intended one with --config FILE');
+  return found[0]||path.resolve(cwd,'redue.config.json');
+}
+export function canonicalConfig(configFile) {
+  return path.join(realObservedPath(path.dirname(configFile)),path.basename(configFile));
+}
+export function projectState(root,configFile) {
+  return path.join(userStateBase(process.platform,process.env,os.homedir()),'vstate',
+    `vstate-${createHash('sha256').update(stateIdentity(root)+'\0'+stateIdentity(canonicalConfig(configFile))).digest('hex').slice(0,16)}`);
+}
+export function readProject(configFile) {
+  const config=JSON.parse(fs.readFileSync(configFile,'utf8'));
+  if(config.schema!==1||!Array.isArray(config.checks)||!config.checks.length)
+    throw Error('config needs schema 1 and at least one check');
+  return {config,root:realObservedPath(path.resolve(path.dirname(configFile),config.root||'.'))};
+}

package/src/python-onboarding.mjs

@@ -0,0 +1,89 @@
+// Python projects for `redue init`: typecheck, lint and test checks that run
+// mypy, pyright, ty, ruff or pytest from the project's .venv under the sandboxed recipe
+// (sandbox.mjs). A tool is proposed when it is installed in .venv/bin. Its
+// arguments are the ones the project runs it with, read from CI workflows,
+// the Makefile, tox, nox, a justfile and shell scripts; without one, the
+// tool's own default (`ruff check`, `ty check`, `pyright`, `pytest`, and
+// `mypy` with its configured files or `.`).
+import fs from 'node:fs';
+import path from 'node:path';
+import {realObservedPath} from './path-identity.mjs';
+import {sandboxCheckInputs,sandboxQualification} from './sandbox.mjs';
+
+const read=file=>{try{return fs.readFileSync(file,'utf8');}catch{return '';}};
+const exists=file=>{try{fs.lstatSync(file);return true;}catch{return false;}};
+const executable=file=>{try{fs.accessSync(file,fs.constants.X_OK);return fs.statSync(file).isFile();}catch{return false;}};
+// Each tool, its kind, and the subcommand it runs as a check.
+export const pythonTools=[{tool:'mypy',kind:'typecheck',sub:[]},{tool:'pyright',kind:'typecheck',sub:[]},
+  {tool:'ty',kind:'typecheck',sub:['check']},{tool:'ruff',kind:'lint',sub:['check']},{tool:'pytest',kind:'test',sub:[]}];
+// The text of a TOML or INI section, up to the next section header.
+const section=(text,header)=>{const at=text.split(/\r?\n/).findIndex(line=>line.trim()===header);
+  if(at<0)return null;const rest=text.split(/\r?\n/).slice(at+1);const end=rest.findIndex(line=>/^\s*\[/.test(line));
+  return (end<0?rest:rest.slice(0,end)).join('\n');};
+// Ways a project starts a tool: through uv, poetry or pdm, `python -m`, or from .venv/bin.
+const wrappers=[/^uv run(?: --(?:frozen|locked|no-sync|offline|quiet|all-extras|all-groups))*(?: --(?:group|extra|with|python|package) [^ ]+)* /,
+  /^poetry run /,/^pdm run /,/^python3?(?:\.\d+)? -m /,/^(?:\.\/)?\.venv\/bin\//,
+  // A variable that names the environment's bin directory: `${PREFIX}mypy`.
+  /^\$\{?[A-Za-z_]+\}?(?=[A-Za-z])/];
+// A tool's arguments in one line of a script or workflow, or null. The line
+// must run the tool and its subcommand plainly; arguments with shell syntax,
+// ones that change files or install packages, and pytest's that run a set
+// chosen from its cache (--lf, --ff, --sw, --nf), show the cache, loop
+// (-f), rewrite snapshots or add to earlier coverage data, are not taken.
+export function toolArgs(line,{tool,sub}){
+  let text=line.trim().replace(/^-\s+/,'').replace(/^run:\s*/,'').replace(/^[@-]+/,'');
+  text=text.split(/\s(?:&&|\|\||;|\|)\s/)[0].replace(/\s+/g,' ').trim();
+  for(let changed=true;changed;){changed=false;for(const wrapper of wrappers)if(wrapper.test(text)){text=text.replace(wrapper,'');changed=true;}}
+  const words=text.split(' ');
+  if(words[0]!==tool||JSON.stringify(words.slice(1,1+sub.length))!==JSON.stringify(sub))return null;
+  const args=words.slice(1+sub.length);
+  if(args.some(arg=>!/^[A-Za-z0-9_./:=,@+%-]+$/.test(arg)||/^--(?:fix|unsafe-fixes|write|install-types|watch|lf|last-failed|ff|failed-first|sw|sw-skip|sw-reset|stepwise|stepwise-skip|stepwise-reset|nf|new-first|cache-show|looponfail|snapshot-update|update-snapshots|inline-snapshot|cov-append)(?:=|$)/.test(arg)||arg==='-f'||arg.startsWith('..')||arg.startsWith('/')))return null;
+  return args;
+}
+// The places a project writes how it runs its tools, in order of preference.
+function scriptTexts(root){
+  const texts=[];
+  const workflows=path.join(root,'.github','workflows');
+  let files=[];try{files=fs.readdirSync(workflows).filter(file=>/\.ya?ml$/.test(file)).sort();}catch{}
+  for(const file of files)texts.push(read(path.join(workflows,file)));
+  for(const file of ['Makefile','makefile','justfile','tox.ini','noxfile.py'])texts.push(read(path.join(root,file)));
+  // Shell scripts: *.sh, or a file whose #! line runs a shell (scripts/check).
+  for(const dir of ['scripts','script','bin','ci']){let names=[];try{names=fs.readdirSync(path.join(root,dir)).sort();}catch{}
+    for(const name of names){const text=read(path.join(root,dir,name)).slice(0,65536);
+      if(name.endsWith('.sh')||/^#!\S*(?:\/|env\s+)(?:ba|z|da)?sh\b/.test(text))texts.push(text);}}
+  return texts;
+}
+// The arguments the project runs `tool` with, or its default.
+export function projectArgs(root,spec,texts=scriptTexts(root)){
+  for(const text of texts)for(const line of text.split(/\r?\n/)){
+    if(/^\s*#/.test(line))continue;
+    const args=toolArgs(line,spec);
+    if(args)return {args,source:'project'};
+  }
+  if(spec.tool!=='mypy')return {args:[],source:'default'};
+  // mypy without targets needs `files` in its configuration.
+  const configured=[section(read(path.join(root,'pyproject.toml')),'[tool.mypy]'),section(read(path.join(root,'mypy.ini')),'[mypy]'),
+    section(read(path.join(root,'.mypy.ini')),'[mypy]'),section(read(path.join(root,'setup.cfg')),'[mypy]')].some(text=>text&&/^\s*files\s*=/m.test(text));
+  return {args:configured?[]:['.'],source:'default'};
+}
+// The Python checks `init` proposes, or null when the root is not a Python
+// project. Each row is ready only once init has run it both ways (bin/redue.mjs).
+export function discoverPythonProject(root){
+  root=realObservedPath(root);
+  if(!['pyproject.toml','setup.cfg','setup.py','requirements.txt'].some(file=>exists(path.join(root,file))))return null;
+  const checks=[],skipped=[];
+  if(!exists(path.join(root,'.venv','pyvenv.cfg'))){
+    skipped.push({kind:'python',reason:'no .venv in the project root; REDUE runs Python tools from the project\'s .venv (uv sync, or Poetry with virtualenvs.in-project)'});
+    return {root,checks,skipped};
+  }
+  const texts=scriptTexts(root);
+  const found=pythonTools.filter(spec=>executable(path.join(root,'.venv','bin',spec.tool)));
+  for(const spec of found){
+    const {args,source}=projectArgs(root,spec,texts);
+    const several=found.filter(other=>other.kind===spec.kind).length>1;
+    checks.push({config:{name:several?`${spec.kind}:${spec.tool}`:spec.kind,kind:spec.kind,qualification:sandboxQualification,
+      command:[`.venv/bin/${spec.tool}`,...spec.sub,...args],...sandboxCheckInputs()},level:'ready',qualification:sandboxQualification,
+      reason:`sandboxed recipe: ${[spec.tool,...spec.sub,...args].join(' ')} from .venv${source==='project'?' as the project runs it':''}; the whole checkout is its input`});
+  }
+  return {root,checks,skipped};
+}