@nocobase/plugin-workflow-javascript 2.1.0-beta.23 → 2.1.0-beta.25

package/dist/externalVersion.js

@@ -13,11 +13,11 @@ module.exports = {
   "antd-style": "3.7.1",
   "@formily/antd-v5": "1.2.3",
   "@ant-design/icons": "5.6.1",
-  "@nocobase/client": "2.1.0-beta.23",
-  "@nocobase/plugin-workflow": "2.1.0-beta.23",
+  "@nocobase/client": "2.1.0-beta.25",
+  "@nocobase/plugin-workflow": "2.1.0-beta.25",
   "antd": "5.24.2",
-  "@nocobase/flow-engine": "2.1.0-beta.23",
+  "@nocobase/flow-engine": "2.1.0-beta.25",
   "react-i18next": "11.18.6",
   "winston": "3.13.0",
-  "@nocobase/server": "2.1.0-beta.23"
+  "@nocobase/server": "2.1.0-beta.25"
 };

package/dist/node_modules/isolated-vm/Dockerfile.alpine

@@ -1,9 +1,9 @@
-FROM node:22-alpine3.20 AS build
+FROM node:22-alpine3.23 AS build
 WORKDIR /isolated-vm
 RUN apk add g++ make python3
 COPY . .
 RUN npm install --ignore-scripts
-RUN MAKEFLAGS=-j$(nproc) npx -y prebuild
+RUN npm run prebuild
 
 FROM scratch
 COPY --from=build /isolated-vm/prebuilds .

package/dist/node_modules/isolated-vm/Dockerfile.debian

@@ -7,6 +7,6 @@ RUN apt-get update && \
   python3
 COPY . .
 RUN npm install --ignore-scripts
-RUN MAKEFLAGS=-j$(nproc) npx -y prebuild
+RUN npm run prebuild
 FROM scratch
 COPY --from=build /isolated-vm/prebuilds .

package/dist/node_modules/isolated-vm/binding.gyp

@@ -3,18 +3,18 @@
 		'default_configuration': 'Release',
 		'configurations': {
 			'Common': {
-				'cflags_cc': [ '-std=c++17', '-g', '-Wno-unknown-pragmas' ],
+				'cflags_cc': [ '-std=c++20', '-g', '-Wno-unknown-pragmas' ],
 				'cflags_cc!': [ '-fno-exceptions' ],
 				'include_dirs': [ './src', './vendor' ],
 				'xcode_settings': {
 					'GCC_ENABLE_CPP_EXCEPTIONS': 'YES',
 					'GCC_GENERATE_DEBUGGING_SYMBOLS': 'YES',
-					'CLANG_CXX_LANGUAGE_STANDARD': 'c++17',
+					'CLANG_CXX_LANGUAGE_STANDARD': 'c++20',
 					'MACOSX_DEPLOYMENT_TARGET': '10.12',
 				},
 				'msvs_settings': {
 					'VCCLCompilerTool': {
-						'AdditionalOptions': [ '-std:c++17', '/GR' ],
+						'AdditionalOptions': [ '-std:c++20' ],
 						'ExceptionHandling': '1',
 					},
 				},
@@ -50,9 +50,18 @@
 			'xcode_settings': {
 				'GCC_ENABLE_CPP_RTTI': 'YES',
 			},
-			'msvs_settings': {
-				'VCCLCompilerTool': {
-					'RuntimeTypeInfo': 'true',
+			# nb: For whatever reason this msvs setting cannot be inherited and must be directly set on
+			# each target
+			'configurations': {
+				'Debug': {
+					'msvs_settings': {
+						'VCCLCompilerTool': { 'RuntimeTypeInfo': 'true' },
+					},
+				},
+				'Release': {
+					'msvs_settings': {
+						'VCCLCompilerTool': { 'RuntimeTypeInfo': 'true' },
+					},
 				},
 			},
 			'conditions': [
@@ -65,7 +74,7 @@
 				'src/external_copy/string.cc',
 				'src/isolate/allocator_nortti.cc',
 				'src/isolate/environment.cc',
-				"src/isolate/cpu_profile_manager.cc",
+				'src/isolate/cpu_profile_manager.cc',
 				'src/isolate/executor.cc',
 				'src/isolate/holder.cc',
 				'src/isolate/inspector.cc',
@@ -107,14 +116,5 @@
 				'src/isolate/allocator_nortti.cc',
 			],
 		},
-		{
-			'target_name': 'action_after_build',
-			'type': 'none',
-			'dependencies': [ 'isolated_vm' ],
-			'copies': [ {
-				'files': [ '<(PRODUCT_DIR)/isolated_vm.node' ],
-				'destination': 'out',
-			} ],
-		},
 	],
 }

package/dist/node_modules/isolated-vm/isolated-vm.js

@@ -1 +1 @@
-(()=>{var e={290:(e,r,_)=>{e.exports=_(794).ivm},794:(e,r,_)=>{e.exports=require(_.ab+"out/isolated_vm.node")}};var r={};function __nccwpck_require__(_){var a=r[_];if(a!==undefined){return a.exports}var i=r[_]={exports:{}};var t=true;try{e[_](i,i.exports,__nccwpck_require__);t=false}finally{if(t)delete r[_]}return i.exports}if(typeof __nccwpck_require__!=="undefined")__nccwpck_require__.ab=__dirname+"/";var _=__nccwpck_require__(290);module.exports=_})();
+(()=>{var __webpack_modules__={290:(e,r,i)=>{e.exports=i(90)(__dirname).ivm},90:(module,__unused_webpack_exports,__nccwpck_require__)=>{const runtimeRequire=true?eval("require"):0;if(typeof runtimeRequire.addon==="function"){module.exports=runtimeRequire.addon.bind(runtimeRequire)}else{module.exports=__nccwpck_require__(403)}},403:(module,__unused_webpack_exports,__nccwpck_require__)=>{var fs=__nccwpck_require__(147);var path=__nccwpck_require__(17);var os=__nccwpck_require__(37);var runtimeRequire=true?eval("require"):0;var vars=process.config&&process.config.variables||{};var prebuildsOnly=!!process.env.PREBUILDS_ONLY;var abi=process.versions.modules;var runtime=isElectron()?"electron":isNwjs()?"node-webkit":"node";var arch=process.env.npm_config_arch||os.arch();var platform=process.env.npm_config_platform||os.platform();var libc=process.env.LIBC||(isAlpine(platform)?"musl":"glibc");var armv=process.env.ARM_VERSION||(arch==="arm64"?"8":vars.arm_version)||"";var uv=(process.versions.uv||"").split(".")[0];module.exports=load;function load(e){return runtimeRequire(load.resolve(e))}load.resolve=load.path=function(e){e=path.resolve(e||".");try{var r=runtimeRequire(path.join(e,"package.json")).name.toUpperCase().replace(/-/g,"_");if(process.env[r+"_PREBUILD"])e=process.env[r+"_PREBUILD"]}catch(e){}if(!prebuildsOnly){var i=getFirst(path.join(e,"build/Release"),matchBuild);if(i)return i;var a=getFirst(path.join(e,"build/Debug"),matchBuild);if(a)return a}var n=resolve(e);if(n)return n;var t=resolve(path.dirname(process.execPath));if(t)return t;var s=["platform="+platform,"arch="+arch,"runtime="+runtime,"abi="+abi,"uv="+uv,armv?"armv="+armv:"","libc="+libc,"node="+process.versions.node,process.versions.electron?"electron="+process.versions.electron:"",true?"webpack=true":0].filter(Boolean).join(" ");throw new Error("No native build was found for "+s+"\n    loaded from: "+e+"\n");function resolve(e){var r=readdirSync(path.join(e,"prebuilds")).map(parseTuple);var i=r.filter(matchTuple(platform,arch)).sort(compareTuples)[0];if(!i)return;var a=path.join(e,"prebuilds",i.name);var n=readdirSync(a).map(parseTags);var t=n.filter(matchTags(runtime,abi));var s=t.sort(compareTags(runtime))[0];if(s)return path.join(a,s.file)}};function readdirSync(e){try{return fs.readdirSync(e)}catch(e){return[]}}function getFirst(e,r){var i=readdirSync(e).filter(r);return i[0]&&path.join(e,i[0])}function matchBuild(e){return/\.node$/.test(e)}function parseTuple(e){var r=e.split("-");if(r.length!==2)return;var i=r[0];var a=r[1].split("+");if(!i)return;if(!a.length)return;if(!a.every(Boolean))return;return{name:e,platform:i,architectures:a}}function matchTuple(e,r){return function(i){if(i==null)return false;if(i.platform!==e)return false;return i.architectures.includes(r)}}function compareTuples(e,r){return e.architectures.length-r.architectures.length}function parseTags(e){var r=e.split(".");var i=r.pop();var a={file:e,specificity:0};if(i!=="node")return;for(var n=0;n<r.length;n++){var t=r[n];if(t==="node"||t==="electron"||t==="node-webkit"){a.runtime=t}else if(t==="napi"){a.napi=true}else if(t.slice(0,3)==="abi"){a.abi=t.slice(3)}else if(t.slice(0,2)==="uv"){a.uv=t.slice(2)}else if(t.slice(0,4)==="armv"){a.armv=t.slice(4)}else if(t==="glibc"||t==="musl"){a.libc=t}else{continue}a.specificity++}return a}function matchTags(e,r){return function(i){if(i==null)return false;if(i.runtime&&i.runtime!==e&&!runtimeAgnostic(i))return false;if(i.abi&&i.abi!==r&&!i.napi)return false;if(i.uv&&i.uv!==uv)return false;if(i.armv&&i.armv!==armv)return false;if(i.libc&&i.libc!==libc)return false;return true}}function runtimeAgnostic(e){return e.runtime==="node"&&e.napi}function compareTags(e){return function(r,i){if(r.runtime!==i.runtime){return r.runtime===e?-1:1}else if(r.abi!==i.abi){return r.abi?-1:1}else if(r.specificity!==i.specificity){return r.specificity>i.specificity?-1:1}else{return 0}}}function isNwjs(){return!!(process.versions&&process.versions.nw)}function isElectron(){if(process.versions&&process.versions.electron)return true;if(process.env.ELECTRON_RUN_AS_NODE)return true;return typeof window!=="undefined"&&window.process&&window.process.type==="renderer"}function isAlpine(e){return e==="linux"&&fs.existsSync("/etc/alpine-release")}load.parseTags=parseTags;load.matchTags=matchTags;load.compareTags=compareTags;load.parseTuple=parseTuple;load.matchTuple=matchTuple;load.compareTuples=compareTuples},147:e=>{"use strict";e.exports=require("fs")},37:e=>{"use strict";e.exports=require("os")},17:e=>{"use strict";e.exports=require("path")}};var __webpack_module_cache__={};function __nccwpck_require__(e){var r=__webpack_module_cache__[e];if(r!==undefined){return r.exports}var i=__webpack_module_cache__[e]={exports:{}};var a=true;try{__webpack_modules__[e](i,i.exports,__nccwpck_require__);a=false}finally{if(a)delete __webpack_module_cache__[e]}return i.exports}if(typeof __nccwpck_require__!=="undefined")__nccwpck_require__.ab=__dirname+"/";var __webpack_exports__=__nccwpck_require__(290);module.exports=__webpack_exports__})();

package/dist/node_modules/isolated-vm/package.json

@@ -1 +1 @@
-{"name":"isolated-vm","version":"5.0.4","description":"Access to multiple isolates","main":"isolated-vm.js","types":"isolated-vm.d.ts","engines":{"node":">=18.0.0"},"scripts":{"install":"prebuild-install || (node-gyp rebuild --release -j max && node-gyp clean)","rebuild":"node-gyp rebuild --release -j max","lint":"find src -name '*.cc' | xargs -n1 clang-tidy","test":"node test.js"},"dependencies":{"prebuild-install":"^7.1.2"},"devDependencies":{"isolated-vm":".","prebuild":"^13.0.1"},"binary":{"module_path":"out"},"repository":{"type":"git","url":"git+https://github.com/laverdet/isolated-vm.git"},"author":"https://github.com/laverdet/","license":"ISC","gypfile":true,"bugs":{"url":"https://github.com/laverdet/isolated-vm/issues"},"homepage":"https://github.com/laverdet/isolated-vm#readme","_lastModified":"2026-04-28T16:00:08.163Z"}
+{"name":"isolated-vm","version":"6.1.2","description":"Access to multiple isolates","main":"isolated-vm.js","types":"isolated-vm.d.ts","engines":{"node":">=22.0.0"},"scripts":{"install":"node-gyp-build || node-gyp rebuild --release -j max","prebuild":"node scripts/run-prebuild.js","rebuild":"node-gyp rebuild --release -j max","lint":"find src -name '*.cc' | xargs -n1 clang-tidy","test":"node test.js"},"dependencies":{"node-gyp-build":"^4.8.4"},"devDependencies":{"isolated-vm":".","prebuildify":"^6.0.1"},"repository":{"type":"git","url":"git+https://github.com/laverdet/isolated-vm.git"},"author":"https://github.com/laverdet/","license":"ISC","gypfile":true,"bugs":{"url":"https://github.com/laverdet/isolated-vm/issues"},"homepage":"https://github.com/laverdet/isolated-vm#readme","_lastModified":"2026-05-06T11:08:55.908Z"}

package/dist/node_modules/isolated-vm/scripts/run-prebuild.js

@@ -0,0 +1,33 @@
+const os = require('node:os');
+const fs = require('node:fs');
+const path = require('node:path');
+const { spawnSync } = require('node:child_process');
+
+const targetArgs = [
+  '--strip',
+  '--no-napi',
+  '--target',
+  '22.22.0',
+  '--target',
+  '24.14.0',
+];
+
+if (process.platform === 'linux') {
+  targetArgs.push('--tag-libc');
+}
+
+const env = {
+  ...process.env,
+  MAKEFLAGS: `-j${os.cpus().length}`,
+};
+
+fs.rmSync(path.join(__dirname, '..', 'prebuilds'), { recursive: true, force: true });
+
+const prebuildifyCli = require.resolve('prebuildify/bin.js');
+const result = spawnSync(process.execPath, [prebuildifyCli, ...targetArgs], { stdio: 'inherit', env });
+
+if (result.error) {
+  throw result.error;
+}
+
+process.exit(result.status ?? 1);

package/dist/node_modules/isolated-vm/src/isolate/allocator.h

@@ -13,14 +13,12 @@ class LimitedAllocator : public v8::ArrayBuffer::Allocator {
 		size_t next_check;
 		int failures = 0;
 
-
 	public:
 		auto Check(size_t length) -> bool;
 		explicit LimitedAllocator(class IsolateEnvironment& env, size_t limit);
 		auto Allocate(size_t length) -> void* final;
 		auto AllocateUninitialized(size_t length) -> void* final;
 		void Free(void* data, size_t length) final;
-		auto Reallocate(void* data, size_t old_length, size_t new_length) -> void* final;
 
 		// This is used by ExternalCopy when an ArrayBuffer is transferred. The memory is not freed but
 		// we should no longer count it against the isolate

package/dist/node_modules/isolated-vm/src/isolate/allocator_nortti.cc

@@ -115,17 +115,6 @@ void LimitedAllocator::Free(void* data, size_t length) {
 	std::free(data);
 }
 
-auto LimitedAllocator::Reallocate(void* data, size_t old_length, size_t new_length) -> void* {
-	auto delta = static_cast<ssize_t>(new_length) - static_cast<ssize_t>(old_length);
-	if (delta > 0) {
-		if (!Check(delta)) {
-			return nullptr;
-		}
-	}
-	env.extra_allocated_memory += delta;
-	return ArrayBuffer::Allocator::Reallocate(data, old_length, new_length);
-}
-
 void LimitedAllocator::AdjustAllocatedSize(ptrdiff_t length) {
 	env.extra_allocated_memory += length;
 }

package/dist/node_modules/isolated-vm/src/isolate/class_handle.h

@@ -92,7 +92,11 @@ class ClassHandle {
 			template <typename... Args>
 			void Add(const char* name, detail::MemberAccessorHolder impl, Args... args) {
 				v8::Local<v8::String> name_handle = v8_symbol(name);
-				proto->SetAccessor(name_handle, impl.getter.callback, impl.setter.callback);
+				v8::Local<v8::FunctionTemplate> setter;
+				if (impl.setter.callback != nullptr) {
+					setter = v8::FunctionTemplate::New(isolate, impl.setter.callback, name_handle);
+				}
+				proto->SetAccessorProperty(name_handle, v8::FunctionTemplate::New(isolate, impl.getter.callback, {}), setter);
 				Add(args...);
 			}
 

package/dist/node_modules/isolated-vm/src/isolate/environment.cc

@@ -40,6 +40,7 @@ static auto GetStackBase() -> void* {
                 base = (void*)((char*)ss.ss_sp - ss.ss_size);
         }
 	return base;
+}
 #elif defined __FreeBSD__
 #include <pthread_np.h>
 static auto GetStackBase() -> void* {

package/dist/node_modules/isolated-vm/src/isolate/environment.h

@@ -108,7 +108,7 @@ class IsolateEnvironment {
 		std::atomic<unsigned int> remotes_count{0};
 		v8::HeapStatistics last_heap {};
 		// Copyable traits used to opt into destructor handle reset
-		std::deque<v8::Persistent<v8::Promise, v8::CopyablePersistentTraits<v8::Promise>>> unhandled_promise_rejections;
+		std::deque<v8::Global<v8::Promise>> unhandled_promise_rejections;
 		StringTable string_table;
 
 		std::vector<v8::Eternal<v8::Data>> specifics;

package/dist/node_modules/isolated-vm/src/isolate/generic/callbacks.h

@@ -157,14 +157,12 @@ struct MemberFunctionHolder : FunctionCallbackImpl {
 };
 
 // Member getters and setters
-struct MemberGetterHolder : GenericCallback<v8::AccessorNameGetterCallback,
-		v8::Local<v8::Name>, const v8::PropertyCallbackInfo<v8::Value>&> {
-	using GenericCallback::GenericCallback;
+struct MemberGetterHolder : FunctionCallbackImpl {
+	using FunctionCallbackImpl::FunctionCallbackImpl;
 };
 
-struct MemberSetterHolder : GenericCallback<v8::AccessorNameSetterCallback,
-		v8::Local<v8::Name>, v8::Local<v8::Value>, const v8::PropertyCallbackInfo<void>&> {
-	using GenericCallback::GenericCallback;
+struct MemberSetterHolder : FunctionCallbackImpl {
+	using FunctionCallbackImpl::FunctionCallbackImpl;
 };
 
 struct MemberAccessorHolder {
@@ -229,12 +227,8 @@ template <
 >
 struct MemberAccessor : detail::MemberAccessorHolder {
 	constexpr MemberAccessor() : MemberAccessorHolder{
-		detail::MemberGetterHolder{detail::MemberGetterHolder::ToCallback<
-			0, typename UnboundGetter::type, UnboundGetter::template invoke<Getter>
-		>()},
-		detail::MemberSetterHolder{detail::MemberSetterHolder::ToCallback<
-			0, typename UnboundSetter::type, UnboundSetter::template invoke<Setter>
-		>()}
+		detail::MemberGetterHolder{detail::MemberGetterHolder::ToCallback<-1, typename UnboundGetter::type, UnboundGetter::template invoke<Getter>>(), 0},
+		detail::MemberSetterHolder{detail::MemberSetterHolder::ToCallback<-1, typename UnboundSetter::type, UnboundSetter::template invoke<Setter>>(), 1},
 	} {}
 
 	private:
@@ -248,10 +242,8 @@ struct MemberAccessor : detail::MemberAccessorHolder {
 template <class GetterSignature, GetterSignature Getter>
 struct MemberAccessor<GetterSignature, Getter, std::nullptr_t, nullptr> : detail::MemberAccessorHolder {
 	constexpr MemberAccessor() : MemberAccessorHolder{
-		detail::MemberGetterHolder{detail::MemberGetterHolder::ToCallback<
-			0, typename UnboundGetter::type, UnboundGetter::template invoke<Getter>
-		>()},
-		detail::MemberSetterHolder{nullptr}
+		detail::MemberGetterHolder{detail::MemberGetterHolder::ToCallback<-1, typename UnboundGetter::type, UnboundGetter::template invoke<Getter>>(), 0},
+		detail::MemberSetterHolder{nullptr},
 	} {}
 
 	private:

package/dist/node_modules/isolated-vm/src/isolate/holder.cc

@@ -63,14 +63,14 @@ void IsolateHolder::ScheduleTask(std::unique_ptr<Runnable> task, bool run_inline
 }
 
 // Methods for v8::TaskRunner
-void IsolateTaskRunner::PostTask(std::unique_ptr<v8::Task> task) {
+void IsolateTaskRunner::PostTaskImpl(std::unique_ptr<v8::Task> task, const v8::SourceLocation& /*location*/) {
 	auto env = weak_env.lock();
 	if (env) {
 		env->GetScheduler().Lock()->tasks.push(std::move(task));
 	}
 }
 
-void IsolateTaskRunner::PostDelayedTask(std::unique_ptr<v8::Task> task, double delay_in_seconds) {
+void IsolateTaskRunner::PostDelayedTaskImpl(std::unique_ptr<v8::Task> task, double delay_in_seconds, const v8::SourceLocation& /*location*/) {
 	// wait_detached erases the type of the lambda into a std::function which must be
 	// copyable. The unique_ptr is stored in a shared pointer so ownership can be handled correctly.
 	auto shared_task = std::make_shared<std::unique_ptr<v8::Task>>(std::move(task));

package/dist/node_modules/isolated-vm/src/isolate/holder.h

@@ -52,9 +52,15 @@ class IsolateTaskRunner final : public TaskRunner {
 		auto operator=(const IsolateTaskRunner&) = delete;
 
 		// Methods for v8::TaskRunner
-		void PostTask(std::unique_ptr<v8::Task> task) final;
-		void PostDelayedTask(std::unique_ptr<v8::Task> task, double delay_in_seconds) final;
-		void PostNonNestableTask(std::unique_ptr<v8::Task> task) final { PostTask(std::move(task)); }
+		void PostTaskImpl(std::unique_ptr<v8::Task> task, const v8::SourceLocation& /*location*/) final;
+		void PostDelayedTaskImpl(std::unique_ptr<v8::Task> task, double delay_in_seconds, const v8::SourceLocation& /*location*/) final;
+		void PostNonNestableTaskImpl(std::unique_ptr<v8::Task> task, const v8::SourceLocation& location) final {
+#if V8_AT_LEAST(13, 3, 241)
+			PostTask(std::move(task), location);
+#else
+			PostTask(std::move(task));
+#endif
+		}
 
 	private:
 		std::weak_ptr<IsolateEnvironment> weak_env;

package/dist/node_modules/isolated-vm/src/isolate/platform_delegate.h

@@ -12,13 +12,13 @@ namespace ivm {
 class TaskRunner : public v8::TaskRunner {
 	public:
 		// Methods for v8::TaskRunner
-		void PostTask(std::unique_ptr<v8::Task> task) override = 0;
-		void PostDelayedTask(std::unique_ptr<v8::Task> task, double delay_in_seconds) override = 0;
-		void PostIdleTask(std::unique_ptr<v8::IdleTask> /*task*/) final { std::terminate(); }
+		void PostTaskImpl(std::unique_ptr<v8::Task> task, const v8::SourceLocation& location) override = 0;
+		void PostDelayedTaskImpl(std::unique_ptr<v8::Task> task, double delay_in_seconds, const v8::SourceLocation& location) override = 0;
+		void PostIdleTaskImpl(std::unique_ptr<v8::IdleTask> /*task*/, const v8::SourceLocation& /*location*/) final { std::terminate(); }
 		// Can't be final because symbol is also used in IsolatePlatformDelegate
 		auto IdleTasksEnabled() -> bool override { return false; };
 		auto NonNestableTasksEnabled() const -> bool final { return true; }
-		void PostNonNestableDelayedTask(std::unique_ptr<v8::Task> /*task*/, double /*delay_in_seconds*/) final { std::terminate(); }
+		// void PostNonNestableDelayedTask(std::unique_ptr<v8::Task> /*task*/, double /*delay_in_seconds*/) final { std::terminate(); }
 		auto NonNestableDelayedTasksEnabled() const -> bool final { return false; }
 };
 

package/dist/node_modules/isolated-vm/src/isolate/remote_handle.h

@@ -17,7 +17,7 @@ namespace detail {
 template <size_t Index, class Type>
 struct HandleTupleElement {
 	HandleTupleElement(v8::Isolate* isolate, v8::Local<Type> local) : persistent{isolate, local} {}
-	v8::Persistent<Type, v8::NonCopyablePersistentTraits<Type>> persistent;
+	v8::Persistent<Type> persistent;
 };
 
 template <class Indices, class ...Types>

package/dist/node_modules/isolated-vm/src/isolate/stack_trace.cc

@@ -100,12 +100,11 @@ void ErrorStackGetter(Local<Name> /*property*/, const PropertyCallbackInfo<Value
 void AttachStackGetter(Local<Object> error, Local<Value> data) {
 	Local<Context> context = Isolate::GetCurrent()->GetCurrentContext();
 	Unmaybe(error->SetPrivate(context, GetPrivateStackSymbol(), data));
-	Unmaybe(error->SetAccessor(
+	Unmaybe(error->SetNativeDataProperty(
 		context,
 		StringTable::Get().stack,
 		ErrorStackGetter, nullptr,
 		Local<Value>(),
-		AccessControl::DEFAULT,
 		PropertyAttribute::DontEnum
 	));
 }

package/dist/node_modules/isolated-vm/src/isolate/stack_trace.h

@@ -13,7 +13,7 @@ class StackTraceHolder : public ClassHandle {
 	private:
 		static void AppendFileLocation(v8::Isolate* isolate, v8::Local<v8::StackFrame> frame, std::stringstream& ss);
 	public:
-		v8::Persistent<v8::StackTrace, v8::CopyablePersistentTraits<v8::StackTrace>> stack_trace;
+		v8::Global<v8::StackTrace> stack_trace;
 		explicit StackTraceHolder(v8::Local<v8::StackTrace> stack_handle);
 		static auto Definition() -> v8::Local<v8::FunctionTemplate>;
 		static void AttachStack(v8::Local<v8::Object> error, v8::Local<v8::StackTrace> stack);

package/dist/node_modules/isolated-vm/src/isolate/util.h

@@ -27,7 +27,7 @@ auto Deref(const v8::Persistent<T>& handle) -> v8::Local<T> {
 }
 
 template <typename T>
-auto Deref(const v8::Persistent<T, v8::CopyablePersistentTraits<T>>& handle) -> v8::Local<T> {
+auto Deref(const v8::Global<T>& handle) -> v8::Local<T> {
 	return v8::Local<T>::New(v8::Isolate::GetCurrent(), handle);
 }
 

package/dist/node_modules/isolated-vm/src/isolate/v8_inspector_wrapper.h

@@ -1,7 +1,9 @@
 #pragma once
 #include "node_wrapper.h"
 #include "./v8_version.h"
-#if V8_AT_LEAST(12, 4, 254)
+#if V8_AT_LEAST(13, 6, 233)
+#include "v8_inspector/nodejs_v24.0.0.h"
+#elif V8_AT_LEAST(12, 4, 254)
 #include "v8_inspector/nodejs_v22.0.0.h"
 #elif V8_AT_LEAST(11, 3, 244)
 #include "v8_inspector/nodejs_v20.0.0.h"

package/dist/node_modules/isolated-vm/src/module/callback.cc

@@ -12,9 +12,13 @@ namespace ivm {
 /**
  * CallbackHandle implementation
  */
+static std::unique_ptr<CallbackHandle> CallbackHandle_New_Wrapper(Local<Function> fn, MaybeLocal<Object> options) {
+	return CallbackHandle::New(fn, options);
+}
+
 auto CallbackHandle::Definition() -> Local<FunctionTemplate> {
 	return Inherit<TransferableHandle>(MakeClass(
-		"Callback", ConstructorFunction<decltype(&New), &New>{}
+		"Callback", ConstructorFunction<decltype(&CallbackHandle_New_Wrapper), &CallbackHandle_New_Wrapper>{}
 	));
 }
 

package/dist/node_modules/isolated-vm/src/module/evaluation.cc

@@ -21,7 +21,6 @@ ScriptOriginHolder::ScriptOriginHolder(MaybeLocal<Object> maybe_options, bool is
 
 ScriptOriginHolder::operator ScriptOrigin() const {
 	return ScriptOrigin{
-			Isolate::GetCurrent(),
 			HandleCast<Local<String>>(filename),
 			line_offset,
 			column_offset,

package/dist/node_modules/isolated-vm/src/module/external_copy_handle.cc

@@ -27,9 +27,15 @@ ExternalCopyHandle::~ExternalCopyHandle() {
 	Isolate::GetCurrent()->AdjustAmountOfExternalAllocatedMemory(-size);
 }
 
+static std::unique_ptr<ExternalCopyHandle> ExternalCopyHandle_New_Wrapper(
+	v8::Local<v8::Value> value, v8::MaybeLocal<v8::Object> options
+) {
+	return ExternalCopyHandle::New(value, options);
+}
+
 auto ExternalCopyHandle::Definition() -> Local<FunctionTemplate> {
 	return Inherit<TransferableHandle>(MakeClass(
-		"ExternalCopy", ConstructorFunction<decltype(&New), &New>{},
+		"ExternalCopy", ConstructorFunction<decltype(&ExternalCopyHandle_New_Wrapper), &ExternalCopyHandle_New_Wrapper>{},
 		"totalExternalSize", StaticAccessor<decltype(&ExternalCopyHandle::TotalExternalSizeGetter), &ExternalCopyHandle::TotalExternalSizeGetter>{},
 		"copy", MemberFunction<decltype(&ExternalCopyHandle::Copy), &ExternalCopyHandle::Copy>{},
 		"copyInto", MemberFunction<decltype(&ExternalCopyHandle::CopyInto), &ExternalCopyHandle::CopyInto>{},

package/dist/node_modules/isolated-vm/src/module/isolate_handle.cc

@@ -39,9 +39,13 @@ auto IsolateHandle::IsolateHandleTransferable::TransferIn() -> Local<Value> {
 
 IsolateHandle::IsolateHandle(shared_ptr<IsolateHolder> isolate) : isolate(std::move(isolate)) {}
 
+static std::unique_ptr<ClassHandle> IsolateHandle_New_Wrapper(v8::MaybeLocal<v8::Object> options) {
+	return IsolateHandle::New(options);
+}
+
 auto IsolateHandle::Definition() -> Local<FunctionTemplate> {
 	return Inherit<TransferableHandle>(MakeClass(
-	 "Isolate", ConstructorFunction<decltype(&New), &New>{},
+		"Isolate", ConstructorFunction<decltype(&IsolateHandle_New_Wrapper), &IsolateHandle_New_Wrapper>{},
 		"createSnapshot", FreeFunction<decltype(&CreateSnapshot), &CreateSnapshot>{},
 		"compileScript", MemberFunction<decltype(&IsolateHandle::CompileScript<1>), &IsolateHandle::CompileScript<1>>{},
 		"compileScriptSync", MemberFunction<decltype(&IsolateHandle::CompileScript<0>), &IsolateHandle::CompileScript<0>>{},
@@ -139,7 +143,7 @@ struct CreateContextRunner : public ThreePhaseTask {
 	void Phase2() final {
 		// Use custom deleter on the shared_ptr which will notify the isolate when we're probably done with this context
 		struct ContextDeleter {
-			void operator() (Persistent<Context>& context) const {
+			void operator() (v8::Persistent<Context>& context) const {
 				auto& env = IsolateEnvironment::GetCurrent();
 				context.Reset();
 				env.GetIsolate()->ContextDisposedNotification();
@@ -483,16 +487,24 @@ auto IsolateHandle::CreateSnapshot(ArrayRange script_handles, MaybeLocal<String>
 			}
 
 			// Methods for v8::TaskRunner
-			void PostTask(std::unique_ptr<v8::Task> task) final {
+			void PostTaskImpl(std::unique_ptr<v8::Task> task, const v8::SourceLocation& /*location*/) final {
 				tasks.write()->push_back(std::move(task));
 			}
-			void PostDelayedTask(std::unique_ptr<v8::Task> task, double /*delay_in_seconds*/) final {
+			void PostDelayedTaskImpl(std::unique_ptr<v8::Task> task, double /*delay_in_seconds*/, const v8::SourceLocation& location) final {
 				if (!done) {
+#if V8_AT_LEAST(13, 3, 241)
+					PostTask(std::move(task), location);
+#else
 					PostTask(std::move(task));
+#endif
 				}
 			}
-			void PostNonNestableTask(std::unique_ptr<v8::Task> task) final {
-				PostTask(std::move(task));
+			void PostNonNestableTaskImpl(std::unique_ptr<v8::Task> task, const v8::SourceLocation& location) final {
+#if V8_AT_LEAST(13, 3, 241)
+					PostTask(std::move(task), location);
+#else
+					PostTask(std::move(task));
+#endif
 			}
 
 		private:

package/dist/node_modules/isolated-vm/src/module/native_module_handle.cc

@@ -49,9 +49,13 @@ auto NativeModuleHandle::NativeModuleTransferable::TransferIn() -> Local<Value>
  */
 NativeModuleHandle::NativeModuleHandle(shared_ptr<NativeModule> module) : module(std::move(module)) {}
 
+static std::unique_ptr<NativeModuleHandle> NativeModuleHandle_New_Wrapper(v8::Local<v8::String> value) {
+    return NativeModuleHandle::New(value);
+}
+
 auto NativeModuleHandle::Definition() -> Local<FunctionTemplate> {
 	return Inherit<TransferableHandle>(MakeClass(
-		"NativeModule", ConstructorFunction<decltype(&New), &New>{},
+		"NativeModule", ConstructorFunction<decltype(&NativeModuleHandle_New_Wrapper), &NativeModuleHandle_New_Wrapper>{},
 		"create", MemberFunction<decltype(&NativeModuleHandle::Create<1>), &NativeModuleHandle::Create<1>>{},
 		"createSync", MemberFunction<decltype(&NativeModuleHandle::Create<0>), &NativeModuleHandle::Create<0>>{}
 	));

package/dist/node_modules/isolated-vm/src/module/reference_handle.cc

@@ -105,9 +105,13 @@ ReferenceData::ReferenceData(
 /**
  * ReferenceHandle implementation
  */
+static std::unique_ptr<ReferenceHandle> ReferenceHandle_New_Wrapper(v8::Local<v8::Value> value, v8::MaybeLocal<v8::Object> options) {
+    return ReferenceHandle::New(value, options);
+}
+
 auto ReferenceHandle::Definition() -> Local<FunctionTemplate> {
 	return Inherit<TransferableHandle>(MakeClass(
-		"Reference", ConstructorFunction<decltype(&New), &New>{},
+		"Reference", ConstructorFunction<decltype(&ReferenceHandle_New_Wrapper), &ReferenceHandle_New_Wrapper>{},
 		"deref", MemberFunction<decltype(&ReferenceHandle::Deref), &ReferenceHandle::Deref>{},
 		"derefInto", MemberFunction<decltype(&ReferenceHandle::DerefInto), &ReferenceHandle::DerefInto>{},
 		"release", MemberFunction<decltype(&ReferenceHandle::Release), &ReferenceHandle::Release>{},

package/dist/node_modules/isolated-vm/vendor/v8_inspector/nodejs_v24.0.0.h

@@ -0,0 +1,426 @@
+// Copyright 2016 the V8 project authors. All rights reserved.
+// Use of this source code is governed by a BSD-style license that can be
+// found in the LICENSE file.
+
+#ifndef V8_V8_INSPECTOR_H_
+#define V8_V8_INSPECTOR_H_
+
+#include <stdint.h>
+
+#include <cctype>
+#include <memory>
+
+#include "v8-isolate.h"       // NOLINT(build/include_directory)
+#include "v8-local-handle.h"  // NOLINT(build/include_directory)
+
+namespace v8 {
+class Context;
+class Name;
+class Object;
+class StackTrace;
+class Value;
+}  // namespace v8
+
+namespace v8_inspector {
+
+namespace internal {
+class V8DebuggerId;
+}  // namespace internal
+
+namespace protocol {
+namespace Debugger {
+namespace API {
+class SearchMatch;
+}
+}  // namespace Debugger
+namespace Runtime {
+namespace API {
+class RemoteObject;
+class StackTrace;
+class StackTraceId;
+}  // namespace API
+}  // namespace Runtime
+namespace Schema {
+namespace API {
+class Domain;
+}
+}  // namespace Schema
+}  // namespace protocol
+
+class V8_EXPORT StringView {
+ public:
+  StringView() : m_is8Bit(true), m_length(0), m_characters8(nullptr) {}
+
+  StringView(const uint8_t* characters, size_t length)
+      : m_is8Bit(true), m_length(length), m_characters8(characters) {}
+
+  StringView(const uint16_t* characters, size_t length)
+      : m_is8Bit(false), m_length(length), m_characters16(characters) {}
+
+  bool is8Bit() const { return m_is8Bit; }
+  size_t length() const { return m_length; }
+
+  // TODO(dgozman): add DCHECK(m_is8Bit) to accessors once platform can be used
+  // here.
+  const uint8_t* characters8() const { return m_characters8; }
+  const uint16_t* characters16() const { return m_characters16; }
+
+ private:
+  bool m_is8Bit;
+  size_t m_length;
+  union {
+    const uint8_t* m_characters8;
+    const uint16_t* m_characters16;
+  };
+};
+
+class V8_EXPORT StringBuffer {
+ public:
+  virtual ~StringBuffer() = default;
+  virtual StringView string() const = 0;
+  // This method copies contents.
+  static std::unique_ptr<StringBuffer> create(StringView);
+};
+
+class V8_EXPORT V8ContextInfo {
+ public:
+  V8ContextInfo(v8::Local<v8::Context> context, int contextGroupId,
+                StringView humanReadableName)
+      : context(context),
+        contextGroupId(contextGroupId),
+        humanReadableName(humanReadableName),
+        hasMemoryOnConsole(false) {}
+
+  v8::Local<v8::Context> context;
+  // Each v8::Context is a part of a group. The group id must be non-zero.
+  int contextGroupId;
+  StringView humanReadableName;
+  StringView origin;
+  StringView auxData;
+  bool hasMemoryOnConsole;
+
+  static int executionContextId(v8::Local<v8::Context> context);
+
+  // Disallow copying and allocating this one.
+  enum NotNullTagEnum { NotNullLiteral };
+  void* operator new(size_t) = delete;
+  void* operator new(size_t, NotNullTagEnum, void*) = delete;
+  void* operator new(size_t, void*) = delete;
+  V8ContextInfo(const V8ContextInfo&) = delete;
+  V8ContextInfo& operator=(const V8ContextInfo&) = delete;
+};
+
+// This debugger id tries to be unique by generating two random
+// numbers, which should most likely avoid collisions.
+// Debugger id has a 1:1 mapping to context group. It is used to
+// attribute stack traces to a particular debugging, when doing any
+// cross-debugger operations (e.g. async step in).
+// See also Runtime.UniqueDebuggerId in the protocol.
+class V8_EXPORT V8DebuggerId {
+ public:
+  V8DebuggerId() = default;
+  V8DebuggerId(const V8DebuggerId&) = default;
+  V8DebuggerId& operator=(const V8DebuggerId&) = default;
+
+  std::unique_ptr<StringBuffer> toString() const;
+  bool isValid() const;
+  std::pair<int64_t, int64_t> pair() const;
+
+ private:
+  friend class internal::V8DebuggerId;
+  explicit V8DebuggerId(std::pair<int64_t, int64_t>);
+
+  int64_t m_first = 0;
+  int64_t m_second = 0;
+};
+
+struct V8_EXPORT V8StackFrame {
+  StringView sourceURL;
+  StringView functionName;
+  int lineNumber;
+  int columnNumber;
+  int scriptId;
+};
+
+class V8_EXPORT V8StackTrace {
+ public:
+  virtual StringView firstNonEmptySourceURL() const = 0;
+  virtual bool isEmpty() const = 0;
+  virtual StringView topSourceURL() const = 0;
+  virtual int topLineNumber() const = 0;
+  virtual int topColumnNumber() const = 0;
+  virtual int topScriptId() const = 0;
+  virtual StringView topFunctionName() const = 0;
+
+  virtual ~V8StackTrace() = default;
+  virtual std::unique_ptr<protocol::Runtime::API::StackTrace>
+  buildInspectorObject(int maxAsyncDepth) const = 0;
+  virtual std::unique_ptr<StringBuffer> toString() const = 0;
+
+  // Safe to pass between threads, drops async chain.
+  virtual std::unique_ptr<V8StackTrace> clone() = 0;
+
+  virtual std::vector<V8StackFrame> frames() const = 0;
+};
+
+class V8_EXPORT V8InspectorSession {
+ public:
+  virtual ~V8InspectorSession() = default;
+
+  // Cross-context inspectable values (DOM nodes in different worlds, etc.).
+  class V8_EXPORT Inspectable {
+   public:
+    virtual v8::Local<v8::Value> get(v8::Local<v8::Context>) = 0;
+    virtual ~Inspectable() = default;
+  };
+  virtual void addInspectedObject(std::unique_ptr<Inspectable>) = 0;
+
+  // Dispatching protocol messages.
+  static bool canDispatchMethod(StringView method);
+  virtual void dispatchProtocolMessage(StringView message) = 0;
+  virtual std::vector<uint8_t> state() = 0;
+  virtual std::vector<std::unique_ptr<protocol::Schema::API::Domain>>
+  supportedDomains() = 0;
+
+  // Debugger actions.
+  virtual void schedulePauseOnNextStatement(StringView breakReason,
+                                            StringView breakDetails) = 0;
+  virtual void cancelPauseOnNextStatement() = 0;
+  virtual void breakProgram(StringView breakReason,
+                            StringView breakDetails) = 0;
+  virtual void setSkipAllPauses(bool) = 0;
+  virtual void resume(bool setTerminateOnResume = false) = 0;
+  virtual void stepOver() = 0;
+  virtual std::vector<std::unique_ptr<protocol::Debugger::API::SearchMatch>>
+  searchInTextByLines(StringView text, StringView query, bool caseSensitive,
+                      bool isRegex) = 0;
+
+  // Remote objects.
+  virtual std::unique_ptr<protocol::Runtime::API::RemoteObject> wrapObject(
+      v8::Local<v8::Context>, v8::Local<v8::Value>, StringView groupName,
+      bool generatePreview) = 0;
+
+  virtual bool unwrapObject(std::unique_ptr<StringBuffer>* error,
+                            StringView objectId, v8::Local<v8::Value>*,
+                            v8::Local<v8::Context>*,
+                            std::unique_ptr<StringBuffer>* objectGroup) = 0;
+  virtual void releaseObjectGroup(StringView) = 0;
+  virtual void triggerPreciseCoverageDeltaUpdate(StringView occasion) = 0;
+
+  struct V8_EXPORT EvaluateResult {
+    enum class ResultType {
+      kNotRun,
+      kSuccess,
+      kException,
+    };
+
+    ResultType type;
+    v8::Local<v8::Value> value;
+  };
+  // Evalaute 'expression' in the provided context. Does the same as
+  // Runtime#evaluate under-the-hood but exposed on the C++ side.
+  virtual EvaluateResult evaluate(v8::Local<v8::Context> context,
+                                  StringView expression,
+                                  bool includeCommandLineAPI = false) = 0;
+
+  // Prepare for shutdown (disables debugger pausing, etc.).
+  virtual void stop() = 0;
+};
+
+struct V8_EXPORT DeepSerializedValue {
+  explicit DeepSerializedValue(std::unique_ptr<StringBuffer> type,
+                               v8::MaybeLocal<v8::Value> value = {})
+      : type(std::move(type)), value(value) {}
+  std::unique_ptr<StringBuffer> type;
+  v8::MaybeLocal<v8::Value> value;
+};
+
+struct V8_EXPORT DeepSerializationResult {
+  explicit DeepSerializationResult(
+      std::unique_ptr<DeepSerializedValue> serializedValue)
+      : serializedValue(std::move(serializedValue)), isSuccess(true) {}
+  explicit DeepSerializationResult(std::unique_ptr<StringBuffer> errorMessage)
+      : errorMessage(std::move(errorMessage)), isSuccess(false) {}
+
+  // Use std::variant when available.
+  std::unique_ptr<DeepSerializedValue> serializedValue;
+  std::unique_ptr<StringBuffer> errorMessage;
+  bool isSuccess;
+};
+
+class V8_EXPORT V8InspectorClient {
+ public:
+  virtual ~V8InspectorClient() = default;
+
+  virtual void runMessageLoopOnPause(int contextGroupId) {}
+  virtual void runMessageLoopOnInstrumentationPause(int contextGroupId) {
+    runMessageLoopOnPause(contextGroupId);
+  }
+  virtual void quitMessageLoopOnPause() {}
+  virtual void runIfWaitingForDebugger(int contextGroupId) {}
+
+  virtual void muteMetrics(int contextGroupId) {}
+  virtual void unmuteMetrics(int contextGroupId) {}
+
+  virtual void beginUserGesture() {}
+  virtual void endUserGesture() {}
+
+  virtual std::unique_ptr<DeepSerializationResult> deepSerialize(
+      v8::Local<v8::Value> v8Value, int maxDepth,
+      v8::Local<v8::Object> additionalParameters) {
+    return nullptr;
+  }
+  virtual std::unique_ptr<StringBuffer> valueSubtype(v8::Local<v8::Value>) {
+    return nullptr;
+  }
+  virtual std::unique_ptr<StringBuffer> descriptionForValueSubtype(
+      v8::Local<v8::Context>, v8::Local<v8::Value>) {
+    return nullptr;
+  }
+  virtual bool isInspectableHeapObject(v8::Local<v8::Object>) { return true; }
+
+  virtual v8::Local<v8::Context> ensureDefaultContextInGroup(
+      int contextGroupId) {
+    return v8::Local<v8::Context>();
+  }
+  virtual void beginEnsureAllContextsInGroup(int contextGroupId) {}
+  virtual void endEnsureAllContextsInGroup(int contextGroupId) {}
+
+  virtual void installAdditionalCommandLineAPI(v8::Local<v8::Context>,
+                                               v8::Local<v8::Object>) {}
+  virtual void consoleAPIMessage(int contextGroupId,
+                                 v8::Isolate::MessageErrorLevel level,
+                                 const StringView& message,
+                                 const StringView& url, unsigned lineNumber,
+                                 unsigned columnNumber, V8StackTrace*) {}
+  virtual v8::MaybeLocal<v8::Value> memoryInfo(v8::Isolate*,
+                                               v8::Local<v8::Context>) {
+    return v8::MaybeLocal<v8::Value>();
+  }
+
+  virtual void consoleTime(v8::Isolate* isolate, v8::Local<v8::String> label) {}
+  virtual void consoleTimeEnd(v8::Isolate* isolate,
+                              v8::Local<v8::String> label) {}
+  virtual void consoleTimeStamp(v8::Isolate* isolate,
+                                v8::Local<v8::String> label) {}
+  virtual void consoleTimeStampWithArgs(
+      v8::Isolate* isolate, v8::Local<v8::String> label,
+      const v8::LocalVector<v8::Value>& args) {}
+  virtual void consoleClear(int contextGroupId) {}
+  virtual double currentTimeMS() { return 0; }
+  typedef void (*TimerCallback)(void*);
+  virtual void startRepeatingTimer(double, TimerCallback, void* data) {}
+  virtual void cancelTimer(void* data) {}
+
+  // TODO(dgozman): this was added to support service worker shadow page. We
+  // should not connect at all.
+  virtual bool canExecuteScripts(int contextGroupId) { return true; }
+
+  virtual void maxAsyncCallStackDepthChanged(int depth) {}
+
+  virtual std::unique_ptr<StringBuffer> resourceNameToUrl(
+      const StringView& resourceName) {
+    return nullptr;
+  }
+
+  // The caller would defer to generating a random 64 bit integer if
+  // this method returns 0.
+  virtual int64_t generateUniqueId() { return 0; }
+
+  virtual void dispatchError(v8::Local<v8::Context>, v8::Local<v8::Message>,
+                             v8::Local<v8::Value>) {}
+};
+
+// These stack trace ids are intended to be passed between debuggers and be
+// resolved later. This allows to track cross-debugger calls and step between
+// them if a single client connects to multiple debuggers.
+struct V8_EXPORT V8StackTraceId {
+  uintptr_t id;
+  std::pair<int64_t, int64_t> debugger_id;
+  bool should_pause = false;
+
+  V8StackTraceId();
+  V8StackTraceId(const V8StackTraceId&) = default;
+  V8StackTraceId(uintptr_t id, const std::pair<int64_t, int64_t> debugger_id);
+  V8StackTraceId(uintptr_t id, const std::pair<int64_t, int64_t> debugger_id,
+                 bool should_pause);
+  explicit V8StackTraceId(StringView);
+  V8StackTraceId& operator=(const V8StackTraceId&) = default;
+  V8StackTraceId& operator=(V8StackTraceId&&) noexcept = default;
+  ~V8StackTraceId() = default;
+
+  bool IsInvalid() const;
+  std::unique_ptr<StringBuffer> ToString();
+};
+
+class V8_EXPORT V8Inspector {
+ public:
+  static std::unique_ptr<V8Inspector> create(v8::Isolate*, V8InspectorClient*);
+  virtual ~V8Inspector() = default;
+
+  // Contexts instrumentation.
+  virtual void contextCreated(const V8ContextInfo&) = 0;
+  virtual void contextDestroyed(v8::Local<v8::Context>) = 0;
+  virtual void resetContextGroup(int contextGroupId) = 0;
+  virtual v8::MaybeLocal<v8::Context> contextById(int contextId) = 0;
+  virtual V8DebuggerId uniqueDebuggerId(int contextId) = 0;
+  virtual uint64_t isolateId() = 0;
+
+  // Various instrumentation.
+  virtual void idleStarted() = 0;
+  virtual void idleFinished() = 0;
+
+  // Async stack traces instrumentation.
+  virtual void asyncTaskScheduled(StringView taskName, void* task,
+                                  bool recurring) = 0;
+  virtual void asyncTaskCanceled(void* task) = 0;
+  virtual void asyncTaskStarted(void* task) = 0;
+  virtual void asyncTaskFinished(void* task) = 0;
+  virtual void allAsyncTasksCanceled() = 0;
+
+  virtual V8StackTraceId storeCurrentStackTrace(StringView description) = 0;
+  virtual void externalAsyncTaskStarted(const V8StackTraceId& parent) = 0;
+  virtual void externalAsyncTaskFinished(const V8StackTraceId& parent) = 0;
+
+  // Exceptions instrumentation.
+  virtual unsigned exceptionThrown(v8::Local<v8::Context>, StringView message,
+                                   v8::Local<v8::Value> exception,
+                                   StringView detailedMessage, StringView url,
+                                   unsigned lineNumber, unsigned columnNumber,
+                                   std::unique_ptr<V8StackTrace>,
+                                   int scriptId) = 0;
+  virtual void exceptionRevoked(v8::Local<v8::Context>, unsigned exceptionId,
+                                StringView message) = 0;
+  virtual bool associateExceptionData(v8::Local<v8::Context>,
+                                      v8::Local<v8::Value> exception,
+                                      v8::Local<v8::Name> key,
+                                      v8::Local<v8::Value> value) = 0;
+
+  // Connection.
+  class V8_EXPORT Channel {
+   public:
+    virtual ~Channel() = default;
+    virtual void sendResponse(int callId,
+                              std::unique_ptr<StringBuffer> message) = 0;
+    virtual void sendNotification(std::unique_ptr<StringBuffer> message) = 0;
+    virtual void flushProtocolNotifications() = 0;
+  };
+  enum ClientTrustLevel { kUntrusted, kFullyTrusted };
+  enum SessionPauseState { kWaitingForDebugger, kNotWaitingForDebugger };
+  // TODO(chromium:1352175): remove default value once downstream change lands.
+  virtual std::unique_ptr<V8InspectorSession> connect(
+      int contextGroupId, Channel*, StringView state,
+      ClientTrustLevel client_trust_level,
+      SessionPauseState = kNotWaitingForDebugger) {
+    return nullptr;
+  }
+
+  // API methods.
+  virtual std::unique_ptr<V8StackTrace> createStackTrace(
+      v8::Local<v8::StackTrace>) = 0;
+  virtual std::unique_ptr<V8StackTrace> captureStackTrace(bool fullStack) = 0;
+};
+
+}  // namespace v8_inspector
+
+#endif  // V8_V8_INSPECTOR_H_

package/dist/node_modules/joi/package.json

@@ -1 +1 @@
-{"name":"joi","description":"Object schema validation","version":"17.13.3","repository":"git://github.com/hapijs/joi","main":"lib/index.js","types":"lib/index.d.ts","browser":"dist/joi-browser.min.js","files":["lib/**/*","dist/*"],"keywords":["schema","validation"],"dependencies":{"@hapi/hoek":"^9.3.0","@hapi/topo":"^5.1.0","@sideway/address":"^4.1.5","@sideway/formula":"^3.0.1","@sideway/pinpoint":"^2.0.0"},"devDependencies":{"@hapi/bourne":"2.x.x","@hapi/code":"8.x.x","@hapi/joi-legacy-test":"npm:@hapi/joi@15.x.x","@hapi/lab":"^25.1.3","@types/node":"^14.18.63","typescript":"4.3.x"},"scripts":{"prepublishOnly":"cd browser && npm install && npm run build","test":"lab -t 100 -a @hapi/code -L -Y","test-cov-html":"lab -r html -o coverage.html -a @hapi/code"},"license":"BSD-3-Clause","_lastModified":"2026-04-28T16:00:08.625Z"}
+{"name":"joi","description":"Object schema validation","version":"17.13.3","repository":"git://github.com/hapijs/joi","main":"lib/index.js","types":"lib/index.d.ts","browser":"dist/joi-browser.min.js","files":["lib/**/*","dist/*"],"keywords":["schema","validation"],"dependencies":{"@hapi/hoek":"^9.3.0","@hapi/topo":"^5.1.0","@sideway/address":"^4.1.5","@sideway/formula":"^3.0.1","@sideway/pinpoint":"^2.0.0"},"devDependencies":{"@hapi/bourne":"2.x.x","@hapi/code":"8.x.x","@hapi/joi-legacy-test":"npm:@hapi/joi@15.x.x","@hapi/lab":"^25.1.3","@types/node":"^14.18.63","typescript":"4.3.x"},"scripts":{"prepublishOnly":"cd browser && npm install && npm run build","test":"lab -t 100 -a @hapi/code -L -Y","test-cov-html":"lab -r html -o coverage.html -a @hapi/code"},"license":"BSD-3-Clause","_lastModified":"2026-05-06T11:08:56.346Z"}

package/dist/node_modules/winston-transport/package.json

@@ -1 +1 @@
-{"name":"winston-transport","description":"Base stream implementations for winston@3 and up.","version":"4.7.0","main":"index.js","browser":"dist/index.js","scripts":{"lint":"eslint test/*.js index.js --resolve-plugins-relative-to ./node_modules/@dabh/eslint-config-populist","pretest":"npm run lint && npm run build","test":"nyc mocha test/*.test.js","report":"nyc report --reporter=lcov","build":"rimraf dist && babel *.js -d ./dist","prepublishOnly":"npm run build"},"repository":{"type":"git","url":"git@github.com:winstonjs/winston-transport.git"},"keywords":["winston","transport","winston3"],"author":"Charlie Robbins <charlie.robbins@gmail.com>","license":"MIT","bugs":{"url":"https://github.com/winstonjs/winston-transport/issues"},"homepage":"https://github.com/winstonjs/winston-transport#readme","dependencies":{"logform":"^2.3.2","readable-stream":"^3.6.0","triple-beam":"^1.3.0"},"devDependencies":{"@types/node":"^20.8.6","abstract-winston-transport":">=0.5.1","assume":"^2.3.0","babel-cli":"^6.26.0","babel-preset-env":"^1.7.0","deep-equal":"^2.0.5","eslint":"^8.8.0","@dabh/eslint-config-populist":"^5.0.0","mocha":"^10.0.0","nyc":"^15.1.0","rimraf":"^5.0.5","winston-compat":"^0.1.5"},"engines":{"node":">= 12.0.0"},"_lastModified":"2026-04-28T16:00:08.939Z"}
+{"name":"winston-transport","description":"Base stream implementations for winston@3 and up.","version":"4.7.0","main":"index.js","browser":"dist/index.js","scripts":{"lint":"eslint test/*.js index.js --resolve-plugins-relative-to ./node_modules/@dabh/eslint-config-populist","pretest":"npm run lint && npm run build","test":"nyc mocha test/*.test.js","report":"nyc report --reporter=lcov","build":"rimraf dist && babel *.js -d ./dist","prepublishOnly":"npm run build"},"repository":{"type":"git","url":"git@github.com:winstonjs/winston-transport.git"},"keywords":["winston","transport","winston3"],"author":"Charlie Robbins <charlie.robbins@gmail.com>","license":"MIT","bugs":{"url":"https://github.com/winstonjs/winston-transport/issues"},"homepage":"https://github.com/winstonjs/winston-transport#readme","dependencies":{"logform":"^2.3.2","readable-stream":"^3.6.0","triple-beam":"^1.3.0"},"devDependencies":{"@types/node":"^20.8.6","abstract-winston-transport":">=0.5.1","assume":"^2.3.0","babel-cli":"^6.26.0","babel-preset-env":"^1.7.0","deep-equal":"^2.0.5","eslint":"^8.8.0","@dabh/eslint-config-populist":"^5.0.0","mocha":"^10.0.0","nyc":"^15.1.0","rimraf":"^5.0.5","winston-compat":"^0.1.5"},"engines":{"node":">= 12.0.0"},"_lastModified":"2026-05-06T11:08:56.647Z"}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@nocobase/plugin-workflow-javascript",
-  "version": "2.1.0-beta.23",
+  "version": "2.1.0-beta.25",
   "displayName": "Workflow: JavaScript",
   "displayName.zh-CN": "工作流：JavaScript 节点",
   "description": "Execute a piece of JavaScript in an isolated Node.js environment.",
@@ -25,7 +25,7 @@
     "@codemirror/state": "^6.4.1",
     "@codemirror/view": "^6.37.2",
     "codemirror": "^6.0.2",
-    "isolated-vm": "^5.0.4",
+    "isolated-vm": "^6.1.2",
     "joi": "^17.13.3",
     "jshint": "^2.13.6",
     "node-gyp": "^10.2.0"
@@ -38,5 +38,5 @@
     "Workflow"
   ],
   "license": "Apache-2.0",
-  "gitHead": "bb4c0d3551bf9eff505b63756dd24a0813231f16"
+  "gitHead": "824f8b8200e9fe086135768934d3ef427b212446"
 }