@isolated-vm/experimental 0.0.8 → 0.0.10

package/addon/value/array.cc

@@ -1,19 +1,19 @@
 module;
 #include "auto_js/export_tag.h"
 export module isolated_vm:value.array;
-import :handle.value_of;
+import :handle.local_of;
 import :value.record;
 import auto_js;
 
 namespace isolated_vm {
 using namespace js;
 
-// value_of<list_tag>
-class EXPORT value_for_array : public value_next<list_tag> {
+// local_of<list_tag>
+class EXPORT local_for_array : public local_next<list_tag> {
 	public:
-		using value_next<list_tag>::value_next;
-		auto set(const runtime_lock& lock, int key, value_of<> value) const -> void;
-		static auto make(const runtime_lock& lock, int capacity = 0) -> value_of<list_tag>;
+		using local_next<list_tag>::local_next;
+		auto set(const runtime_lock& lock, int key, local_of<> value) const -> void;
+		static auto make(const runtime_lock& lock, int capacity = 0) -> local_of<list_tag>;
 };
 
 } // namespace isolated_vm

package/addon/value/array_buffer.cc

@@ -1,7 +1,7 @@
 module;
 #include "auto_js/export_tag.h"
 export module isolated_vm:value.array_buffer;
-import :handle.bound_value;
+import :handle.local_of;
 import :handle.value_of;
 import :value.object;
 import auto_js;
@@ -10,43 +10,52 @@ import std;
 namespace isolated_vm {
 using namespace js;
 
-// value_of<data_block_tag>
-class EXPORT value_for_data_block : public value_next<data_block_tag> {
+// local_of<data_block_tag>
+class EXPORT local_for_data_block : public local_next<data_block_tag> {
 	public:
-		using value_next<data_block_tag>::value_next;
+		using local_next<data_block_tag>::local_next;
 		[[nodiscard]] auto inspect() const -> value_typeof;
 };
 
-// bound_value<data_block_tag>
-class EXPORT bound_value_for_data_block : public bound_value_next<data_block_tag> {
+// value_of<data_block_tag>
+class EXPORT value_for_data_block : public value_next<data_block_tag> {
 	public:
-		using bound_value_next<data_block_tag>::bound_value_next;
+		using value_next<data_block_tag>::value_next;
 		[[nodiscard]] auto byte_length() const -> std::size_t;
 		[[nodiscard]] auto data() const -> std::byte*;
 		explicit operator js::array_buffer() const;
 		explicit operator std::span<std::byte>() const;
 };
 
-// value_of<array_buffer_tag>
-class EXPORT value_for_array_buffer : public value_next<array_buffer_tag> {
+// local_of<array_buffer_tag>
+class EXPORT local_for_array_buffer : public local_next<array_buffer_tag> {
 	public:
-		using value_next<array_buffer_tag>::value_next;
-		static auto make(const runtime_lock& lock, js::array_buffer buffer) -> value_of<array_buffer_tag>;
+		using local_next<array_buffer_tag>::local_next;
+		static auto make(const runtime_lock& lock, js::array_buffer buffer) -> local_of<array_buffer_tag>;
 };
 
-// value_of<array_buffer_view_tag>
-class EXPORT value_for_array_buffer_view : public value_next<array_buffer_view_tag> {
+// local_of<array_buffer_view_tag>
+class EXPORT local_for_array_buffer_view : public local_next<array_buffer_view_tag> {
 	public:
-		using value_next<array_buffer_view_tag>::value_next;
+		using local_next<array_buffer_view_tag>::local_next;
 		[[nodiscard]] auto inspect() const -> value_typeof;
 };
 
-// bound_value<typed_array_tag_of<Type>>
+// value_of<typed_array_tag_of<Type>>
 template <class Type>
-class EXPORT bound_value_for_typed_array_of : public bound_value_next<typed_array_tag_of<Type>> {
+class EXPORT value_for_typed_array_of : public value_next<typed_array_tag_of<Type>> {
+	public:
+		using value_next<typed_array_tag_of<Type>>::value_next;
+		[[nodiscard]] auto buffer() const -> local_of<data_block_tag>;
+		[[nodiscard]] auto byte_offset() const -> std::size_t;
+		[[nodiscard]] auto size() const -> std::size_t;
+};
+
+// value_of<data_view_tag>
+class EXPORT value_for_data_view : public value_next<data_view_tag> {
 	public:
-		using bound_value_next<typed_array_tag_of<Type>>::bound_value_next;
-		[[nodiscard]] auto buffer() const -> value_of<data_block_tag>;
+		using value_next<data_view_tag>::value_next;
+		[[nodiscard]] auto buffer() const -> local_of<data_block_tag>;
 		[[nodiscard]] auto byte_offset() const -> std::size_t;
 		[[nodiscard]] auto size() const -> std::size_t;
 };

package/addon/value/function.cc

@@ -6,17 +6,17 @@ namespace isolated_vm {
 using namespace js;
 
 template <class Result>
-auto value_for_function::apply(const runtime_lock& lock, auto&& args) -> Result {
-	using args_type = std::vector<value_of<>>;
-	auto undefined = js::transfer_in_strict<value_of<>>(std::monostate{}, lock);
+auto local_for_function::apply(const runtime_lock& lock, auto&& args) -> Result {
+	using args_type = std::vector<local_of<>>;
+	auto undefined = js::transfer_in_strict<local_of<>>(std::monostate{}, lock);
 	auto argv = js::transfer_in_strict<args_type>(std::forward<decltype(args)>(args), lock);
 	auto result = invoke(lock, undefined, argv);
 	return js::transfer_out<Result>(result, lock);
 }
 
 template <class Result>
-auto value_for_function::call(const runtime_lock& lock, auto&&... args) -> Result {
-	using args_type = std::array<value_of<>, sizeof...(args) + 1>;
+auto local_for_function::call(const runtime_lock& lock, auto&&... args) -> Result {
+	using args_type = std::array<local_of<>, sizeof...(args) + 1>;
 	auto argv = js::transfer_in_strict<args_type>(
 		std::tuple_cat(
 			std::tuple{std::monostate{}},

package/addon/value/function.h.cc

@@ -1,17 +1,17 @@
 module;
 #include "auto_js/export_tag.h"
 export module isolated_vm:value.function;
-import :handle.value_of;
+import :handle.local_of;
 import :support.lock_fwd;
 import :value.primitive;
 
 namespace isolated_vm {
 using namespace js;
 
-// value_of<function_tag>
-class EXPORT value_for_function : public value_next<function_tag> {
+// local_of<function_tag>
+class EXPORT local_for_function : public local_next<function_tag> {
 	public:
-		using value_next<function_tag>::value_next;
+		using local_next<function_tag>::local_next;
 
 		template <class Result = std::monostate>
 		auto apply(const runtime_lock& lock, auto&& args) -> Result;
@@ -20,7 +20,7 @@ class EXPORT value_for_function : public value_next<function_tag> {
 		auto call(const runtime_lock& lock, auto&&... args) -> Result;
 
 	private:
-		auto invoke(const runtime_lock& lock, value_of<> that, std::span<value_of<>> argv) -> value_of<>;
+		auto invoke(const runtime_lock& lock, local_of<> that, std::span<local_of<>> argv) -> local_of<>;
 };
 
 } // namespace isolated_vm

package/addon/value/object.cc

@@ -6,10 +6,10 @@ import :value.primitive;
 namespace isolated_vm {
 using namespace js;
 
-// value_of<object_tag>
-class EXPORT value_for_object : public value_next<object_tag> {
+// local_of<object_tag>
+class EXPORT local_for_object : public local_next<object_tag> {
 	public:
-		using value_next<object_tag>::value_next;
+		using local_next<object_tag>::local_next;
 		[[nodiscard]] auto inspect() const -> value_typeof;
 };
 

package/addon/value/primitive.cc

@@ -1,7 +1,7 @@
 module;
 #include "auto_js/export_tag.h"
 export module isolated_vm:value.primitive;
-import :handle.bound_value;
+import :handle.local_of;
 import :handle.value_of;
 import auto_js;
 import std;
@@ -50,9 +50,9 @@ export enum class value_typeof : std::uint8_t {
 };
 
 // value & primitive
-class EXPORT value_for_value : public value_next<value_tag> {
+class EXPORT local_for_value : public local_next<value_tag> {
 	public:
-		using value_next<value_tag>::value_next;
+		using local_next<value_tag>::local_next;
 		[[nodiscard]] auto is_array() const -> bool;
 		[[nodiscard]] auto is_bigint() const -> bool;
 		[[nodiscard]] auto is_boolean() const -> bool;
@@ -65,90 +65,90 @@ class EXPORT value_for_value : public value_next<value_tag> {
 		[[nodiscard]] auto inspect() const -> value_typeof;
 };
 
-class EXPORT value_for_primitive : public value_next<primitive_tag> {
+class EXPORT local_for_primitive : public local_next<primitive_tag> {
 	public:
-		using value_next<primitive_tag>::value_next;
+		using local_next<primitive_tag>::local_next;
 		[[nodiscard]] auto inspect() const -> value_typeof;
 };
 
 // null & undefined
-class EXPORT value_for_undefined : public value_next<undefined_tag> {
+class EXPORT local_for_undefined : public local_next<undefined_tag> {
 	public:
-		using value_next<undefined_tag>::value_next;
-		static auto make(const basic_lock& lock) -> value_of<undefined_tag>;
+		using local_next<undefined_tag>::local_next;
+		static auto make(const basic_lock& lock) -> local_of<undefined_tag>;
 };
 
-class EXPORT value_for_null : public value_next<null_tag> {
+class EXPORT local_for_null : public local_next<null_tag> {
 	public:
-		using value_next<null_tag>::value_next;
-		static auto make(const basic_lock& lock) -> value_of<null_tag>;
+		using local_next<null_tag>::local_next;
+		static auto make(const basic_lock& lock) -> local_of<null_tag>;
 };
 
 // boolean
-class EXPORT value_for_boolean : public value_next<boolean_tag> {
+class EXPORT local_for_boolean : public local_next<boolean_tag> {
 	public:
-		using value_next<boolean_tag>::value_next;
-		static auto make(const basic_lock& lock, bool value) -> value_of<boolean_tag>;
+		using local_next<boolean_tag>::local_next;
+		static auto make(const basic_lock& lock, bool value) -> local_of<boolean_tag>;
 };
 
-class EXPORT bound_value_for_boolean : public bound_value_next<boolean_tag> {
+class EXPORT value_for_boolean : public value_next<boolean_tag> {
 	public:
-		using bound_value_next<boolean_tag>::bound_value_next;
+		using value_next<boolean_tag>::value_next;
 		[[nodiscard]] explicit operator bool() const;
 };
 
 // number
-class EXPORT value_for_number : public value_next<number_tag> {
+class EXPORT local_for_number : public local_next<number_tag> {
 	public:
-		using value_next<number_tag>::value_next;
+		using local_next<number_tag>::local_next;
 		[[nodiscard]] auto inspect() const -> value_typeof;
-		static auto make(const basic_lock& lock, double value) -> value_of<number_tag_of<double>>;
-		static auto make(const basic_lock& lock, std::int32_t value) -> value_of<number_tag_of<std::int32_t>>;
+		static auto make(const basic_lock& lock, double value) -> local_of<number_tag_of<double>>;
+		static auto make(const basic_lock& lock, std::int32_t value) -> local_of<number_tag_of<std::int32_t>>;
 };
 
-class EXPORT bound_value_for_number : public bound_value_next<number_tag> {
+class EXPORT value_for_number : public value_next<number_tag> {
 	public:
-		using bound_value_next<number_tag>::bound_value_next;
+		using value_next<number_tag>::value_next;
 		[[nodiscard]] explicit operator double() const;
 		[[nodiscard]] explicit operator std::int32_t() const;
 };
 
 // name
-class EXPORT value_for_name : public value_next<name_tag> {
+class EXPORT local_for_name : public local_next<name_tag> {
 	public:
-		using value_next<name_tag>::value_next;
+		using local_next<name_tag>::local_next;
 		[[nodiscard]] auto inspect() const -> value_typeof;
 };
 
 // string
-class EXPORT value_for_string : public value_next<string_tag> {
+class EXPORT local_for_string : public local_next<string_tag> {
 	public:
-		using value_next<string_tag>::value_next;
+		using local_next<string_tag>::local_next;
 		[[nodiscard]] auto inspect() const -> value_typeof;
 		[[nodiscard]] auto is_latin1() const -> bool;
-		static auto make(const basic_lock& lock, std::u16string_view value) -> value_of<string_tag_of<char16_t>>;
-		static auto make(const basic_lock& lock, std::string_view value) -> value_of<string_tag_of<char>>;
+		static auto make(const basic_lock& lock, std::u16string_view value) -> local_of<string_tag_of<char16_t>>;
+		static auto make(const basic_lock& lock, std::string_view value) -> local_of<string_tag_of<char>>;
 };
 
-class EXPORT bound_value_for_string : public bound_value_next<string_tag> {
+class EXPORT value_for_string : public value_next<string_tag> {
 	public:
-		using bound_value_next<string_tag>::bound_value_next;
+		using value_next<string_tag>::value_next;
 		[[nodiscard]] explicit operator std::string() const;
 		[[nodiscard]] explicit operator std::u16string() const;
 };
 
 // bigint
-class EXPORT value_for_bigint : public value_next<bigint_tag> {
+class EXPORT local_for_bigint : public local_next<bigint_tag> {
 	public:
-		using value_next<bigint_tag>::value_next;
+		using local_next<bigint_tag>::local_next;
 		[[nodiscard]] auto inspect() const -> value_typeof;
-		static auto make(const runtime_lock& lock, js::bigint value) -> value_of<bigint_tag_of<js::bigint>>;
-		static auto make(const basic_lock& lock, std::int64_t value) -> value_of<bigint_tag_of<std::int64_t>>;
+		static auto make(const runtime_lock& lock, js::bigint value) -> local_of<bigint_tag_of<js::bigint>>;
+		static auto make(const basic_lock& lock, std::int64_t value) -> local_of<bigint_tag_of<std::int64_t>>;
 };
 
-class EXPORT bound_value_for_bigint : public bound_value_next<bigint_tag> {
+class EXPORT value_for_bigint : public value_next<bigint_tag> {
 	public:
-		using bound_value_next<bigint_tag>::bound_value_next;
+		using value_next<bigint_tag>::value_next;
 		[[nodiscard]] explicit operator js::bigint() const;
 		[[nodiscard]] explicit operator std::int64_t() const;
 };

package/addon/value/prototype.cc

@@ -1,21 +1,21 @@
 module;
 #include "auto_js/export_tag.h"
 export module isolated_vm:value.prototype;
-import :handle.value_of;
+import :handle.local_of;
 import :support.callback_storage;
 
 namespace isolated_vm {
 using namespace js;
 
-// value_of<prototype_tag>
-class EXPORT value_for_prototype : public value_next<prototype_tag> {
+// local_of<prototype_tag>
+class EXPORT local_for_prototype : public local_next<prototype_tag> {
 	public:
-		using value_next<prototype_tag>::value_next;
-		[[nodiscard]] static auto make(const basic_lock& lock, runtime_callback_data_allocated_type data, int length) -> value_of<function_prototype_tag>;
-		[[nodiscard]] static auto make(const basic_lock& lock, runtime_callback_data_span_type data, int length) -> value_of<function_prototype_tag>;
+		using local_next<prototype_tag>::local_next;
+		[[nodiscard]] static auto make(const basic_lock& lock, runtime_callback_data_allocated_type data, int length) -> local_of<function_prototype_tag>;
+		[[nodiscard]] static auto make(const basic_lock& lock, runtime_callback_data_span_type data, int length) -> local_of<function_prototype_tag>;
 
 		template <class Type>
-		[[nodiscard]] static auto make(const basic_lock& lock, runtime_callback_function_storage<Type> data, int length) -> value_of<function_prototype_tag> {
+		[[nodiscard]] static auto make(const basic_lock& lock, runtime_callback_function_storage<Type> data, int length) -> local_of<function_prototype_tag> {
 			auto data_span = std::span{reinterpret_cast<std::byte*>(&data), sizeof(data)};
 			return make(lock, data_span, length);
 		}

package/addon/value/record.cc

@@ -6,45 +6,45 @@ import :value.vector;
 namespace isolated_vm {
 using namespace js;
 
-// value_of<record_tag>
-class EXPORT value_for_record : public value_next<record_tag> {
+// local_of<record_tag>
+class EXPORT local_for_record : public local_next<record_tag> {
 	public:
-		using value_next<record_tag>::value_next;
-		auto set(const runtime_lock& lock, value_of<> key, value_of<> value) const -> void;
-		static auto make(const runtime_lock& lock) -> value_of<record_tag>;
+		using local_next<record_tag>::local_next;
+		auto set(const runtime_lock& lock, local_of<> key, local_of<> value) const -> void;
+		static auto make(const runtime_lock& lock) -> local_of<record_tag>;
 };
 
-// bound_value<record_tag>
-class EXPORT bound_value_for_record : public bound_value_next<record_tag> {
+// value_of<record_tag>
+class EXPORT value_for_record : public value_next<record_tag> {
 	private:
-		using internal_keys_type = bound_value<vector_tag>;
+		using internal_keys_type = value_of<vector_tag>;
 
 	public:
-		using bound_value_next<record_tag>::bound_value_next;
-		using key_type = value_of<primitive_tag>;
-		using mapped_type = value_of<>;
+		using value_next<record_tag>::value_next;
+		using key_type = local_of<primitive_tag>;
+		using mapped_type = local_of<>;
 		using value_type = std::pair<key_type, mapped_type>;
 
 	private:
 		class EXPORT iterator_transform {
 			public:
-				explicit iterator_transform(const bound_value_for_record& subject);
-				auto operator()(value_of<> key) const -> value_type;
+				explicit iterator_transform(const value_for_record& subject);
+				auto operator()(local_of<> key) const -> value_type;
 
 			private:
-				const bound_value_for_record* subject_;
+				const value_for_record* subject_;
 		};
 
 	public:
 		using range_type = std::ranges::transform_view<std::views::all_t<const internal_keys_type&>, iterator_transform>;
 		using iterator = std::ranges::iterator_t<range_type>;
 
-		[[nodiscard]] auto get(value_of<name_tag> key) const -> value_of<>;
-		[[nodiscard]] auto get(value_of<number_tag> key) const -> value_of<>;
-		[[nodiscard]] auto get(value_of<primitive_tag> key) const -> value_of<>;
-		[[nodiscard]] auto has(value_of<name_tag> key) const -> bool;
-		[[nodiscard]] auto has(value_of<number_tag> key) const -> bool;
-		[[nodiscard]] auto has(value_of<primitive_tag> key) const -> bool;
+		[[nodiscard]] auto get(local_of<name_tag> key) const -> local_of<>;
+		[[nodiscard]] auto get(local_of<number_tag> key) const -> local_of<>;
+		[[nodiscard]] auto get(local_of<primitive_tag> key) const -> local_of<>;
+		[[nodiscard]] auto has(local_of<name_tag> key) const -> bool;
+		[[nodiscard]] auto has(local_of<number_tag> key) const -> bool;
+		[[nodiscard]] auto has(local_of<primitive_tag> key) const -> bool;
 		[[nodiscard]] auto into_range() const -> range_type;
 		[[nodiscard]] auto size() const -> std::size_t;
 

package/addon/value/value.cc

@@ -1,5 +1,5 @@
 export module isolated_vm:value;
-export import :handle.bound_value;
+export import :handle.local_of;
 export import :handle.value_of;
 export import :support.lock_fwd;
 export import :value.array_buffer;

package/addon/value/vector.cc

@@ -1,7 +1,7 @@
 module;
 #include "auto_js/export_tag.h"
 export module isolated_vm:value.vector;
-import :handle.bound_value;
+import :handle.local_of;
 import :handle.value_of;
 import :value.object;
 import auto_js;
@@ -11,12 +11,12 @@ import util;
 namespace isolated_vm {
 using namespace js;
 
-// bound_value<vector_tag>
-class EXPORT bound_value_for_vector : public bound_value_next<vector_tag> {
+// value_of<vector_tag>
+class EXPORT value_for_vector : public value_next<vector_tag> {
 	public:
 		class iterator;
-		using bound_value_next<vector_tag>::bound_value_next;
-		using value_type = value_of<>;
+		using value_next<vector_tag>::value_next;
+		using value_type = local_of<>;
 
 		[[nodiscard]] auto begin() const -> iterator;
 		[[nodiscard]] auto end() const -> iterator;
@@ -26,15 +26,15 @@ class EXPORT bound_value_for_vector : public bound_value_next<vector_tag> {
 		mutable std::uint32_t size_{};
 };
 
-class EXPORT bound_value_for_vector::iterator : public util::random_access_iterator_facade<std::int32_t, std::int64_t> {
+class EXPORT value_for_vector::iterator : public util::random_access_iterator_facade<std::int32_t, std::int64_t> {
 	public:
 		using arithmetic_facade::operator+;
 		using difference_type = arithmetic_facade::difference_type;
 		using size_type = std::uint32_t;
-		using value_type = bound_value_for_vector::value_type;
+		using value_type = value_for_vector::value_type;
 
 		iterator() = default;
-		iterator(bound_value_for_vector subject, size_type index);
+		iterator(value_for_vector subject, size_type index);
 
 		auto operator*() const -> value_type;
 
@@ -49,7 +49,7 @@ class EXPORT bound_value_for_vector::iterator : public util::random_access_itera
 	private:
 		constexpr auto operator+() const -> size_type { return index_; }
 
-		bound_value_for_vector subject_;
+		value_for_vector subject_;
 		size_type index_{};
 };
 

package/backend/backend.cts

@@ -0,0 +1,7 @@
+/* eslint-disable @typescript-eslint/no-require-imports */
+import backend = require("#backend_cjs");
+
+// Exports must be enumerated because this imports from the native module which cannot declare ESM
+// exports.
+const { initialize, Agent, Module, NativeModule, Realm, Script } = backend;
+module.exports = { initialize, Agent, Module, NativeModule, Realm, Script };

package/backend/backend.d.cts

@@ -0,0 +1,87 @@
+type CapabilityMake = import("@isolated-vm/experimental/frontend/realm", { with: { "resolution-mode": "import" }}).Realm.CapabilityMake;
+type _Agent = import("@isolated-vm/experimental/frontend/agent", { with: { "resolution-mode": "import" }}).Agent;
+type _Module = import("@isolated-vm/experimental/frontend/module", { with: { "resolution-mode": "import" }}).Module;
+type _Reference<T> = import("@isolated-vm/experimental/frontend/reference", { with: { "resolution-mode": "import" }}).Reference<T>;
+type CompileModuleOptions = import("@isolated-vm/experimental/frontend/agent", { with: { "resolution-mode": "import" }}).Agent.CompileModuleOptions;
+type CompileScriptOptions = import("@isolated-vm/experimental/frontend/agent", { with: { "resolution-mode": "import" }}).Agent.CompileScriptOptions;
+type CreateAgentOptions = import("@isolated-vm/experimental/frontend/agent", { with: { "resolution-mode": "import" }}).Agent.CreateOptions;
+type CreateCapabilityOptions = import("@isolated-vm/experimental/frontend/realm", { with: { "resolution-mode": "import" }}).Realm.CreateCapabilityOptions;
+type CreateNativeModuleOptions = import("@isolated-vm/experimental/frontend/native_module", { with: { "resolution-mode": "import" }}).NativeModule.CreateOptions;
+type MaybeCompletionOf<T> = import("@isolated-vm/experimental/utility/completion", { with: { "resolution-mode": "import" }}).MaybeCompletionOf<T>;
+type ModuleLinkRecord = import("@isolated-vm/experimental/frontend/module", { with: { "resolution-mode": "import" }}).Module.LinkRecord;
+type RunScriptOptions = import("@isolated-vm/experimental/frontend/script", { with: { "resolution-mode": "import" }}).Script.RunScriptOptions;
+
+interface InheritedClasses {
+	Agent: object;
+	Module: object;
+}
+
+export const initialize: (inherited: InheritedClasses) => void;
+
+declare const Secret: unique symbol;
+/** @internal */
+export type Secret = typeof Secret;
+
+export class Agent {
+	readonly #private;
+	protected constructor(secret: Secret, ...args: unknown[]);
+	disposeAsync(): Promise<void>;
+	compileModule(code: string, options?: CompileModuleOptions): Promise<MaybeCompletionOf<_Module>>;
+	compileScript(code: string, options?: CompileScriptOptions): Promise<MaybeCompletionOf<Script>>;
+	createRealm(): Promise<Realm | null>;
+	static create(options?: CreateAgentOptions): Promise<_Agent>;
+}
+
+export class Module {
+	readonly #private;
+	protected constructor(secret: Secret, ...args: unknown[]);
+	/** @internal */ _link(realm: Realm | null, linker: ModuleLinkRecord): Promise<void>;
+	evaluate(realm: Realm | null): Promise<MaybeCompletionOf<unknown>>;
+}
+
+export class NativeModule {
+	readonly #private;
+	protected constructor(secret: Secret, ...args: unknown[]);
+	instantiate(realm: Realm | null): Promise<Module | null>;
+	static create(filename: string, options: CreateNativeModuleOptions): Promise<NativeModule>;
+}
+
+export class Realm {
+	readonly #private;
+	protected constructor(secret: Secret, ...args: unknown[]);
+	acquireGlobalObject(): Promise<_Reference<Record<string, unknown>>>;
+	createCapability(make: CapabilityMake, options: CreateCapabilityOptions): Promise<Module | null>;
+	instantiateRuntime(): Promise<Module | null>;
+}
+
+export class Reference {
+	readonly #private;
+	protected constructor(secret: Secret, ...args: unknown[]);
+	copy(): Promise<unknown>;
+	get(property: string): Promise<Reference | null>;
+	set(property: string, value: unknown): Promise<true | null>;
+	invoke(args: unknown[]): Promise<MaybeCompletionOf<unknown>>;
+}
+
+export class Script {
+	readonly #private;
+	protected constructor(secret: Secret, ...args: unknown[]);
+	run(realm: Realm | null, options?: RunScriptOptions): Promise<MaybeCompletionOf<unknown>>;
+}
+
+export class SubscriberCapability {
+	readonly #private;
+	protected constructor(secret: Secret, ...args: unknown[]);
+	send(message: unknown): Promise<boolean>;
+}
+
+/** @internal */
+declare const exports: {
+	initialize: typeof initialize;
+	Agent: typeof Agent;
+	Module: typeof Module;
+	NativeModule: typeof NativeModule;
+	Realm: typeof Realm;
+	Script: typeof Script;
+};
+export default exports;

package/backend/host.cts

@@ -0,0 +1,41 @@
+/* eslint-disable @typescript-eslint/no-require-imports */
+import fs = require("node:fs");
+import process = require("node:process");
+
+const arch = function() {
+	const { arch } = process;
+	// eslint-disable-next-line @typescript-eslint/switch-exhaustiveness-check
+	switch (arch) {
+		case "arm64":
+		case "x64":
+			return arch;
+		default:
+			throw new Error(`Unsupported architecture: ${arch}`);
+	}
+}();
+
+/** @internal */
+const host = function() {
+	const { platform } = process;
+	// eslint-disable-next-line @typescript-eslint/switch-exhaustiveness-check
+	switch (platform) {
+		case "linux": {
+			const libc = function() {
+				try {
+					if (fs.readFileSync("/usr/bin/ldd", "latin1").includes("ld-musl-")) {
+						return "musl" as const;
+					}
+				} catch {}
+				return "gnu" as const;
+			}();
+			return `linux-${arch}-${libc}` as const;
+		}
+		case "darwin":
+		case "win32":
+			return `${platform}-${arch}` as const;
+		default:
+			throw new Error(`Unsupported platform: ${platform}`);
+	}
+}();
+
+export = host;

package/backend/require.cts

@@ -0,0 +1,17 @@
+/* eslint-disable @typescript-eslint/no-require-imports */
+import host = require("#host_cjs");
+
+// All hosts enumerated to assist with bundlers. This file can be replaced with a condition.
+module.exports = function(): unknown {
+	switch (host) {
+		case "darwin-arm64": return require("@isolated-vm/experimental-darwin-arm64");
+		case "darwin-x64": return require("@isolated-vm/experimental-darwin-x64");
+		case "linux-arm64-gnu": return require("@isolated-vm/experimental-linux-arm64-gnu");
+		case "linux-arm64-musl": return require("@isolated-vm/experimental-linux-arm64-musl");
+		case "linux-x64-musl": return require("@isolated-vm/experimental-linux-x64-musl");
+		case "linux-x64-gnu": return require("@isolated-vm/experimental-linux-x64-gnu");
+		case "win32-x64": return require("@isolated-vm/experimental-win32-x64");
+		case "win32-arm64":
+		default: throw new Error(`Unsupported platform: ${host}`);
+	}
+}();

package/dist/backend/backend.cjs

@@ -0,0 +1,9 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+/* eslint-disable @typescript-eslint/no-require-imports */
+const backend = require("#backend_cjs");
+// Exports must be enumerated because this imports from the native module which cannot declare ESM
+// exports.
+const { initialize, Agent, Module, NativeModule, Realm, Script } = backend;
+module.exports = { initialize, Agent, Module, NativeModule, Realm, Script };
+//# sourceMappingURL=backend.cjs.map

package/dist/backend/backend.cjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"backend.cjs","sourceRoot":"","sources":["../../backend/backend.cts"],"names":[],"mappings":";;AAAA,0DAA0D;AAC1D,wCAAyC;AAEzC,kGAAkG;AAClG,WAAW;AACX,MAAM,EAAE,UAAU,EAAE,KAAK,EAAE,MAAM,EAAE,YAAY,EAAE,KAAK,EAAE,MAAM,EAAE,GAAG,OAAO,CAAC;AAC3E,MAAM,CAAC,OAAO,GAAG,EAAE,UAAU,EAAE,KAAK,EAAE,MAAM,EAAE,YAAY,EAAE,KAAK,EAAE,MAAM,EAAE,CAAC"}