@fluid-app/widget-runtime 0.1.0

package/README.md

@@ -0,0 +1,77 @@
+# `@fluid-app/widget-runtime`
+
+Remote DOM runtime for third-party Fluid widgets.
+
+The package has two deliberately small public entry points:
+
+- `@fluid-app/widget-runtime` mounts a widget worker into a host element.
+- `@fluid-app/widget-runtime/worker` starts a worker containing authored React widgets and exposes declared host capabilities.
+
+Widget discovery, descriptor validation, catalog access, publishing, and builder registration belong to portal packages and the CLI. This package owns only the host/worker execution boundary.
+
+## Host
+
+```tsx
+import { mountRemoteDomWidget } from "@fluid-app/widget-runtime/remote-dom";
+
+const handle = mountRemoteDomWidget({
+  host: document.querySelector("#widget")!,
+  artifact: {
+    packageId: "example.widgets",
+    version: "1.0.0",
+    widgetType: "Greeting",
+    workerEntryUrl: "https://cdn.example.com/widget.js",
+    cssUrls: [],
+    assetUrls: [],
+    capabilities: [{ name: "account", version: "1" }],
+  },
+  props: { name: "Ada" },
+  callCapability: (capability, method, payload) =>
+    portalCapabilities.call(capability, method, payload),
+});
+
+await handle.ready;
+handle.updateProps({ name: "Grace" });
+handle.dispose();
+```
+
+Each mount creates one module worker and one Remote DOM thread. Disposal releases the thread, worker, styles, event listeners, and rendered nodes. The host sanitizes all mutations, URLs, CSS, events, and serializable values before applying them to a shadow root.
+
+## Worker
+
+```tsx
+import {
+  startRemoteDomWidgetWorker,
+  useRemoteDomCapability,
+} from "@fluid-app/widget-runtime/worker";
+
+function Greeting({ name }: { readonly name: string }) {
+  const account = useRemoteDomCapability("account");
+  return (
+    <button onClick={() => account.call("openProfile")}>Hello {name}</button>
+  );
+}
+
+startRemoteDomWidgetWorker({ widgets: { Greeting } });
+```
+
+Workers can render arbitrary supported HTML and CSS through upstream Remote DOM. The runtime disables selected network, storage, nested-worker, and fresh-realm globals where the worker environment permits it. Host calls are limited to capabilities declared by the widget package descriptor.
+
+## Threat model
+
+Widget catalog approval is a trust decision: approved packages are trusted
+application code supplied by a company or Droplet owner. Worker-global
+lockdown, capability validation, mutation sanitization, URL policy, resource
+limits, and shadow-root isolation are defense in depth around that trusted
+code. They protect the host DOM and narrow accidental ambient access, but they
+do not constitute a complete network sandbox or a substitute for package
+review, catalog authorization, browser isolation, or server-side access
+control.
+
+## Non-goals
+
+- No classic script loading or browser globals.
+- No legacy widget registration or descriptor conversion.
+- No catalog or package validation API.
+- No worker pooling, heartbeat, diagnostics framework, or version disabling.
+- No compatibility layer for legacy portal SDK hooks.

package/dist/Thread-0eUyc0Hw.cjs

@@ -0,0 +1,591 @@
+//#region ../../../node_modules/.pnpm/@quilted+threads@4.1.0_@preact+signals-core@1.14.3/node_modules/@quilted/threads/build/esm/constants.mjs
+const SERIALIZE_METHOD = Symbol.for("quilt.threads.serialize");
+const TRANSFERABLE = Symbol.for("quilt.threads.transferable");
+//#endregion
+//#region ../../../node_modules/.pnpm/@quilted+threads@4.1.0_@preact+signals-core@1.14.3/node_modules/@quilted/threads/build/esm/memory.mjs
+const RETAIN_METHOD = Symbol.for("quilt.threads.retain");
+const RELEASE_METHOD = Symbol.for("quilt.threads.release");
+/**
+* Indicates that a value is being manually memory-managed across threads by this library.
+*/
+function isMemoryManageable(value) {
+	return Boolean(value && value[RETAIN_METHOD] && value[RELEASE_METHOD]);
+}
+/**
+* Marks a value as being used so it will not be automatically released. Calling `retain` will,
+* by default, deeply retain the value — that is, it will traverse into nested array elements
+* and object properties, and retain every `retain`-able thing it finds.
+*
+* You will typically use this alongside also storing that value in a variable that lives outside
+* the context of the function where that value was received.
+*
+* @example
+* import {retain} from '@quilted/threads';
+*
+* const allUsers = new Set<User>();
+*
+* async function sayHello(user: User) {
+*   allUsers.add(user);
+*   retain(user);
+*   return `Hey, ${await user.fullName()}!`;
+* }
+*/
+function retain(value, { deep = true } = {}) {
+	return retainInternal(value, deep, /* @__PURE__ */ new Map());
+}
+function retainInternal(value, deep, seen) {
+	const seenValue = seen.get(value);
+	if (seenValue) return seenValue;
+	const canRetain = isMemoryManageable(value);
+	if (canRetain) value[RETAIN_METHOD]();
+	seen.set(value, canRetain);
+	if (deep) {
+		if (Array.isArray(value)) {
+			const nestedCanRetain = value.reduce((canRetain, item) => retainInternal(item, deep, seen) || canRetain, canRetain);
+			seen.set(value, nestedCanRetain);
+			return nestedCanRetain;
+		}
+		if (isBasicObject$1(value)) {
+			const nestedCanRetain = Object.keys(value).reduce((canRetain, key) => retainInternal(value[key], deep, seen) || canRetain, canRetain);
+			seen.set(value, nestedCanRetain);
+			return nestedCanRetain;
+		}
+	}
+	return canRetain;
+}
+/**
+* Once you are no longer using the a `retain`-ed value, you can use this function to mark it as
+* being unused. Like `retain()`, this function will apply to all nested array elements and object
+* properties.
+*
+* @example
+* import {retain} from '@quilted/threads';
+*
+* const allUsers = new Set<User>();
+*
+* function removeUser(user: User) {
+*   allUsers.delete(user);
+*   release(user);
+* }
+*/
+function release(value, { deep = true } = {}) {
+	return releaseInternal(value, deep, /* @__PURE__ */ new Map());
+}
+function releaseInternal(value, deep, seen) {
+	const seenValue = seen.get(value);
+	if (seenValue) return seenValue;
+	const canRelease = isMemoryManageable(value);
+	if (canRelease) value[RELEASE_METHOD]();
+	seen.set(value, canRelease);
+	if (deep) {
+		if (Array.isArray(value)) {
+			const nestedCanRelease = value.reduce((canRelease, item) => releaseInternal(item, deep, seen) || canRelease, canRelease);
+			seen.set(value, nestedCanRelease);
+			return nestedCanRelease;
+		}
+		if (isBasicObject$1(value)) {
+			const nestedCanRelease = Object.keys(value).reduce((canRelease, key) => releaseInternal(value[key], deep, seen) || canRelease, canRelease);
+			seen.set(value, nestedCanRelease);
+			return nestedCanRelease;
+		}
+	}
+	return canRelease;
+}
+function isBasicObject$1(value) {
+	if (value == null || typeof value !== "object") return false;
+	const prototype = Object.getPrototypeOf(value);
+	return prototype == null || prototype === Object.prototype;
+}
+//#endregion
+//#region ../../../node_modules/.pnpm/@quilted+events@2.1.5/node_modules/@quilted/events/build/esm/abort/NestedAbortController.mjs
+/**
+* An `AbortController` that will automatically abort when any of
+* its "parent" `AbortController`s abort. This is useful for when
+* you have nested asynchronous operations that may abort independently.
+* The `AbortController` can also be independently aborted.
+*
+* To associate the parent `AbortController`s, pass their signals
+* as arguments to the constructor.
+*
+* @example
+* import {NestedAbortController} from '@shopify/events';
+*
+* const parent = new AbortController();
+* const nested = new NestedAbortController(parent.signal);
+*
+* parent.abort();
+* nested.signal.aborted; // true
+*/
+var NestedAbortController = class extends AbortController {
+	constructor(...parents) {
+		super();
+		const abortedSignal = parents.find((signal) => signal.aborted);
+		if (abortedSignal) this.abort(abortedSignal.reason);
+		else {
+			const abort = (event) => this.abort(event.target.reason);
+			const options = { signal: this.signal };
+			for (const signal of parents) signal.addEventListener("abort", abort, options);
+		}
+	}
+};
+//#endregion
+//#region ../../../node_modules/.pnpm/@quilted+threads@4.1.0_@preact+signals-core@1.14.3/node_modules/@quilted/threads/build/esm/errors.mjs
+var ThreadClosedError = class extends Error {
+	constructor() {
+		super("You attempted to call a function on a closed thread.");
+	}
+};
+//#endregion
+//#region ../../../node_modules/.pnpm/@quilted+threads@4.1.0_@preact+signals-core@1.14.3/node_modules/@quilted/threads/build/esm/nanoid.mjs
+let a = "useandom-26T198340PX75pxJACKVERYMINDBUSHWOLF_GQZbfghjklqvwyzrict";
+function nanoid(e = 21) {
+	let t = "", r = crypto.getRandomValues(new Uint8Array(e));
+	for (let n = 0; n < e; n++) t += a[63 & r[n]];
+	return t;
+}
+//#endregion
+//#region ../../../node_modules/.pnpm/@quilted+threads@4.1.0_@preact+signals-core@1.14.3/node_modules/@quilted/threads/build/esm/functions/ThreadFunctionsAutomatic.mjs
+/**
+* A strategy for managing functions across threads that automatically releases
+* functions when they are no longer needed. This is done by deserializing functions
+* into a proxy that can be called, and wrapping that proxy in a `FinalizationRegistry`,
+* which allows us to send a message to the parent thread when the function is no
+* longer used.
+*
+* @see https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/FinalizationRegistry
+*/
+var ThreadFunctionsAutomatic = class {
+	#functionsToId = /* @__PURE__ */ new Map();
+	#idsToFunction = /* @__PURE__ */ new Map();
+	#idsToProxy = /* @__PURE__ */ new Map();
+	#finalization = /* @__PURE__ */ new WeakMap();
+	get(id) {
+		return this.#idsToFunction.get(id);
+	}
+	release(id) {
+		const func = this.#idsToFunction.get(id);
+		if (func) {
+			this.#idsToFunction.delete(id);
+			this.#functionsToId.delete(func);
+		}
+		return Boolean(func);
+	}
+	serialize(func) {
+		let id = this.#functionsToId.get(func);
+		if (id == null) {
+			id = nanoid();
+			this.#functionsToId.set(func, id);
+			this.#idsToFunction.set(id, func);
+		}
+		return id;
+	}
+	deserialize(id, thread) {
+		let proxy = this.#idsToProxy.get(id)?.deref();
+		if (proxy) return proxy;
+		proxy = (...args) => {
+			if (!this.#idsToProxy.has(id)) throw new Error("You attempted to call a function that was already revoked.");
+			return thread.call((callID, args, transferable) => {
+				thread.messages.send([
+					3,
+					callID,
+					id,
+					args
+				], transferable);
+			}, args);
+		};
+		this.#finalizationRegistry(thread)?.register(proxy, id);
+		this.#idsToProxy.set(id, new WeakRef(proxy));
+		return proxy;
+	}
+	#finalizationRegistry(thread) {
+		let finalization = this.#finalization.get(thread);
+		if (typeof FinalizationRegistry === "undefined") return;
+		if (!finalization) {
+			finalization = new FinalizationRegistry((id) => {
+				thread.messages.send([5, id]);
+			});
+			this.#finalization.set(thread, finalization);
+		}
+		return finalization;
+	}
+};
+//#endregion
+//#region ../../../node_modules/.pnpm/@quilted+threads@4.1.0_@preact+signals-core@1.14.3/node_modules/@quilted/threads/build/esm/serialization/shared.mjs
+function isIterator(value) {
+	return value != null && (Symbol.asyncIterator in value || Symbol.iterator in value) && typeof value.next === "function";
+}
+function isBasicObject(value) {
+	if (value == null || typeof value !== "object") return false;
+	const prototype = Object.getPrototypeOf(value);
+	return prototype == null || prototype === Object.prototype;
+}
+//#endregion
+//#region ../../../node_modules/.pnpm/@quilted+threads@4.1.0_@preact+signals-core@1.14.3/node_modules/@quilted/threads/build/esm/serialization/ThreadSerializationStructuredClone.mjs
+const FUNCTION = "_@f";
+const ASYNC_ITERATOR = "_@i";
+/**
+* A thread encoder that can transfer supports a wide variety of JavaScript types by
+* converting them to a format that the [`structuredClone`](https://developer.mozilla.org/en-US/docs/Web/API/Web_Workers_API/Structured_clone_algorithm)
+* algorithm can process. This
+*
+* Additionally, this encoder will convert functions into a JSON-friendly representation.
+* These functions will use a manual memory management technique to ensure they can be
+* garbage collected by default, but can be configured to use a `WeakRef`-based automatic
+* memory management system by setting the `garbageCollection: 'weak-ref'` option.
+*/
+var ThreadSerializationStructuredClone = class {
+	#customSerializer;
+	#customDeserializer;
+	constructor(options) {
+		this.#customSerializer = options?.serialize;
+		this.#customDeserializer = options?.deserialize;
+	}
+	/**
+	* Serializes a value into a structured cloning-compatible format that can be transferred between threads.
+	*/
+	serialize(value, thread, transferable) {
+		return this.#serializeInternal(value, thread, transferable);
+	}
+	#serializeInternal(value, thread, transferable, seen = /* @__PURE__ */ new Map(), isApplyingDefault = false) {
+		if (value == null) return value;
+		if (seen.has(value)) return seen.get(value);
+		seen.set(value, void 0);
+		if (typeof value === "object") {
+			if (this.#customSerializer && !isApplyingDefault) {
+				const customValue = this.#customSerializer(value, (value) => this.#serializeInternal(value, thread, transferable, seen, true), thread, transferable);
+				if (customValue !== void 0) {
+					seen.set(value, customValue);
+					return customValue;
+				}
+			}
+			if (value[TRANSFERABLE]) {
+				transferable?.push(value);
+				seen.set(value, value);
+				return value;
+			}
+			const serializeValue = (value) => {
+				return this.#serializeInternal(value, thread, transferable, seen);
+			};
+			if (typeof value[SERIALIZE_METHOD] === "function") {
+				const result = value[SERIALIZE_METHOD]({ serialize: serializeValue });
+				seen.set(value, result);
+				return result;
+			}
+			if (Array.isArray(value)) {
+				const result = value.map((item) => serializeValue(item));
+				seen.set(value, result);
+				return result;
+			}
+			if (value instanceof Map) {
+				const entries = [...value.entries()].map(([key, value]) => {
+					return [serializeValue(key), serializeValue(value)];
+				});
+				const result = new Map(entries);
+				seen.set(value, result);
+				return result;
+			}
+			if (value instanceof Set) {
+				const entries = [...value].map((entry) => serializeValue(entry));
+				const result = new Set(entries);
+				seen.set(value, result);
+				return result;
+			}
+			const valueIsIterator = isIterator(value);
+			if (isBasicObject(value) || valueIsIterator) {
+				const result = {};
+				for (const key of Object.keys(value)) result[key] = serializeValue(value[key]);
+				if (valueIsIterator) {
+					result.next ??= serializeValue(value.next.bind(value));
+					result.return ??= serializeValue(value.return.bind(value));
+					result.throw ??= serializeValue(value.throw.bind(value));
+					result[ASYNC_ITERATOR] = true;
+				}
+				seen.set(value, result);
+				return result;
+			}
+		}
+		if (typeof value === "function") {
+			const serialized = thread.functions.serialize(value, thread, transferable);
+			const result = { [FUNCTION]: serialized };
+			seen.set(value, result);
+			return result;
+		}
+		seen.set(value, value);
+		return value;
+	}
+	/**
+	* Deserializes a structured cloning-compatible value from another thread.
+	*/
+	deserialize(value, thread) {
+		return this.#deserializeInternal(value, thread);
+	}
+	#deserializeInternal(value, thread, isApplyingDefault = false) {
+		if (value == null) return value;
+		if (typeof value === "object") {
+			if (this.#customDeserializer && !isApplyingDefault) {
+				const customValue = this.#customDeserializer(value, (value) => this.#deserializeInternal(value, thread, true), thread);
+				if (customValue !== void 0) return customValue;
+			}
+			if (value == null) return value;
+			if (Array.isArray(value)) return value.map((value) => this.#deserializeInternal(value, thread));
+			if (value instanceof Map) return new Map([...value].map(([key, value]) => [this.#deserializeInternal(key, thread), this.#deserializeInternal(value, thread)]));
+			if (value instanceof Set) return new Set([...value].map((entry) => this.#deserializeInternal(entry, thread)));
+			if (FUNCTION in value) return thread.functions.deserialize(value[FUNCTION], thread);
+			if (!isBasicObject(value)) return value;
+			const result = {};
+			for (const key of Object.keys(value)) if (key === ASYNC_ITERATOR) result[Symbol.asyncIterator] = () => result;
+			else result[key] = this.#deserializeInternal(value[key], thread);
+			return result;
+		}
+		return value;
+	}
+};
+//#endregion
+//#region ../../../node_modules/.pnpm/@quilted+threads@4.1.0_@preact+signals-core@1.14.3/node_modules/@quilted/threads/build/esm/Thread.mjs
+/**
+* An object that can serialize and deserialize values communicated between two threads.
+*/
+/**
+* An object that can serialize and deserialize values communicated between two threads.
+*/
+/**
+* Options to customize the creation of a `ThreadSerialization` instance.
+*/
+/**
+* Options to customize the creation of a `Thread` instance.
+*/
+/**
+* An object backing a `Thread` that provides the message-passing interface
+* that allows communication to flow between environments. This message-passing
+* interface is based on the [`postMessage` interface](https://developer.mozilla.org/en-US/docs/Web/API/Window/postMessage),
+* which is easily adaptable to many JavaScript objects and environments.
+*/
+/**
+* A map of messages that can be sent between threads.
+*/
+/**
+* The possible data payloads that can be transferred between threads.
+*/
+/**
+* A helper type that extracts all callable methods that can be safely proxied
+* between threads; that is, ones which return a promise or async iterator.
+*/
+/**
+* A thread represents a target JavaScript environment that exposes a set
+* of callable, asynchronous methods. The thread takes care of automatically
+* encoding and decoding its arguments and return values, so you can interact
+* with it as if its methods were implemented in the same environment as your
+* own code.
+*/
+var Thread = class {
+	/**
+	* An object that exposes the methods that can be called on the paired thread.
+	* This object will automatically encode and decode arguments and return values
+	* as necessary.
+	*/
+	/**
+	* An object that exposes the methods that can be called on this thread by the
+	* paired thread. To set these methods, pass the `exports` option when creating
+	* a new `Thread`.
+	*/
+	/**
+	* An object that provides the message-passing interface that allows communication
+	* to flow between environments.
+	*/
+	/**
+	* An object that manages how functions are proxied between threads.
+	*/
+	/**
+	* An object that manages how values are serialized and deserialized between threads.
+	*/
+	/**
+	* An `AbortSignal` that indicates whether the communication channel is still open.
+	*/
+	get signal() {
+		return this.#abort.signal;
+	}
+	/**
+	* A boolean indicating whether the communication channel is still open.
+	*/
+	get closed() {
+		return this.#abort.signal.aborted;
+	}
+	#abort;
+	#idsToResolver = /* @__PURE__ */ new Map();
+	constructor(messages, { imports, exports, functions = new ThreadFunctionsAutomatic(), serialization = new ThreadSerializationStructuredClone(), signal } = {}) {
+		this.messages = messages;
+		this.#abort = signal ? new NestedAbortController(signal) : new AbortController();
+		this.exports = exports ?? {};
+		this.imports = createThreadImports(this.#handlerForCall.bind(this), imports);
+		this.functions = functions;
+		this.serialization = serialization;
+		this.functions.start?.(this);
+		this.serialization.start?.(this);
+		this.signal.addEventListener("abort", () => {
+			for (const id of this.#idsToResolver.keys()) this.#resolveCall(id, void 0, new ThreadClosedError());
+			this.#idsToResolver.clear();
+		}, { once: true });
+		messages.listen(async (rawData) => {
+			if (!(Array.isArray(rawData) && typeof rawData[0] === "number")) return;
+			const data = rawData;
+			switch (data[0]) {
+				case 1: {
+					const [, id, property, args] = data;
+					const func = this.exports[property] ?? (() => {
+						throw new Error(`No '${property}' method is exported from this thread`);
+					});
+					await this.#callLocal(func, args, (value, error, transferable) => {
+						this.messages.send([
+							2,
+							id,
+							value,
+							error
+						], transferable);
+					});
+					break;
+				}
+				case 3: {
+					const [, callID, funcID, args] = data;
+					const func = this.functions.get(funcID, this) ?? missingThreadFunction;
+					await this.#callLocal(func, args, (value, error, transferable) => {
+						this.messages.send([
+							4,
+							callID,
+							value,
+							error
+						], transferable);
+					});
+					break;
+				}
+				case 2:
+				case 4:
+					this.#resolveCall(...data.slice(1));
+					break;
+				case 5: {
+					const id = data[1];
+					this.functions.release(id, this);
+					break;
+				}
+			}
+		}, { signal: this.signal });
+	}
+	/**
+	* Closes the communication channel between the two threads. This will prevent
+	* any further communication between the threads, and will clean up any memory
+	* associated with in-progress communication. It will also reject any inflight
+	* function calls between threads with a `ThreadClosedError`.
+	*/
+	close() {
+		this.#abort.abort();
+	}
+	/**
+	* Requests that the thread provide the context needed to make a function
+	* call between threads. You provide this method a function to call and the
+	* unserialized arguments you wish to call it with, and the thread will call
+	* the function you provided with a serialized call ID, the serialized arguments,
+	* and any transferable objects that need to be passed between threads.
+	*/
+	call(func, args) {
+		if (this.closed) return Promise.reject(new ThreadClosedError());
+		const transferable = [];
+		const serialized = this.serialization.serialize(args, this, transferable);
+		const id = nanoid();
+		const done = this.#waitForResult(id);
+		func(id, serialized, transferable);
+		return done;
+	}
+	async #callLocal(func, args, withResult) {
+		try {
+			const result = this.functions.call ? await this.functions.call(func, args, this) : await func(...this.serialization.deserialize(args, this));
+			const transferable = [];
+			withResult(this.serialization.serialize(result, this, transferable), void 0, transferable);
+		} catch (error) {
+			withResult(void 0, this.serialization.serialize(error, this));
+		}
+	}
+	#handlerForCall(property) {
+		return (...args) => {
+			try {
+				if (typeof property !== "string" && typeof property !== "number") throw new Error(`Can’t call a symbol method on a thread: ${property.toString()}`);
+				return this.call((id, serializedArgs, transferable) => {
+					this.messages.send([
+						1,
+						id,
+						property,
+						serializedArgs
+					], transferable);
+				}, args);
+			} catch (error) {
+				return Promise.reject(error);
+			}
+		};
+	}
+	#resolveCall(...args) {
+		const callID = args[0];
+		const resolver = this.#idsToResolver.get(callID);
+		if (resolver) {
+			resolver(...args);
+			this.#idsToResolver.delete(callID);
+		}
+	}
+	#waitForResult(id) {
+		const promise = new Promise((resolve, reject) => {
+			this.#idsToResolver.set(id, (_, value, error) => {
+				if (error == null) resolve(this.serialization.deserialize(value, this));
+				else reject(this.serialization.deserialize(error, this));
+			});
+		});
+		Object.defineProperty(promise, Symbol.asyncIterator, { async *value() {
+			const result = await promise;
+			Object.defineProperty(result, Symbol.asyncIterator, { value: () => result });
+			yield* result;
+		} });
+		return promise;
+	}
+};
+function createThreadImports(handlerForImport, imported) {
+	let call;
+	if (imported == null) {
+		if (typeof Proxy !== "function") throw new Error(`You must pass an array of callable methods in environments without Proxies.`);
+		const cache = /* @__PURE__ */ new Map();
+		call = new Proxy({}, { get(_target, property) {
+			if (cache.has(property)) return cache.get(property);
+			const handler = handlerForImport(property);
+			cache.set(property, handler);
+			return handler;
+		} });
+	} else {
+		call = {};
+		for (const method of imported) Object.defineProperty(call, method, {
+			value: handlerForImport(method),
+			writable: false,
+			configurable: true,
+			enumerable: true
+		});
+	}
+	return call;
+}
+function missingThreadFunction() {
+	throw new Error(`You attempted to call a function that is not stored. It may have already been released.`);
+}
+//#endregion
+Object.defineProperty(exports, "Thread", {
+	enumerable: true,
+	get: function() {
+		return Thread;
+	}
+});
+Object.defineProperty(exports, "release", {
+	enumerable: true,
+	get: function() {
+		return release;
+	}
+});
+Object.defineProperty(exports, "retain", {
+	enumerable: true,
+	get: function() {
+		return retain;
+	}
+});
+
+//# sourceMappingURL=Thread-0eUyc0Hw.cjs.map