@capsule-run/sdk 0.8.3 → 0.8.5

package/dist/polyfills/unenv-runtime/npm/debug.d.mts

@@ -0,0 +1,15 @@
+// https://www.npmjs.com/package/debug
+import type { Debug } from "debug";
+declare const debug: Debug;
+export declare const coerce: unknown;
+export declare const disable: unknown;
+export declare const enable: unknown;
+export declare const enabled: unknown;
+export declare const formatArgs: unknown;
+export declare const log: unknown;
+export declare const selectColor: unknown;
+export declare const humanize: any;
+export declare const names: unknown;
+export declare const skips: unknown;
+export declare const formatters: unknown;
+export default debug;

package/dist/polyfills/unenv-runtime/npm/debug.mjs

@@ -0,0 +1,43 @@
+function createDebug(namespace) {
+	return Object.assign((...args) => {
+		const env = globalThis.process?.env.DEBUG;
+		if (!env || env !== "*" && !env.startsWith(namespace)) return;
+		console.debug(...args);
+	}, {
+		color: "#000000",
+		diff: 0,
+		enabled: true,
+		log: console.debug.bind(console),
+		namespace,
+		destroy: () => false,
+		extend: (ns, _del) => createDebug(namespace + ns)
+	});
+}
+const debug = Object.assign(createDebug, {
+	coerce: (val) => val,
+	disable: () => "",
+	enable: (_namespaces) => {},
+	enabled: (_namespaces) => true,
+	formatArgs(args) {
+		args[0] = `${this.namespace} ${args[0]}`;
+	},
+	log: console.debug.bind(console),
+	selectColor: (_namespace) => 0,
+	humanize: (num) => `${num}ms`,
+	inspectOpts: {},
+	names: [],
+	skips: [],
+	formatters: {}
+});
+export const coerce = debug.coerce;
+export const disable = debug.disable;
+export const enable = debug.enable;
+export const enabled = debug.enabled;
+export const formatArgs = debug.formatArgs;
+export const log = debug.log;
+export const selectColor = debug.selectColor;
+export const humanize = debug.humanize;
+export const names = debug.names;
+export const skips = debug.skips;
+export const formatters = debug.formatters;
+export default debug;

package/dist/polyfills/unenv-runtime/npm/fsevents.d.mts

@@ -0,0 +1,16 @@
+// https://www.npmjs.com/package/fsevents
+declare const _default: {
+	watch(_dir: string, _cb: (...args: any[]) => any);
+	getInfo(path: string, _flags: number, _id: string): {
+		event: string;
+		type: string;
+		flags: number;
+		changes: {
+			inode: boolean;
+			finder: boolean;
+			access: boolean;
+			xattrs: boolean;
+		};
+	};
+};
+export default _default;

package/dist/polyfills/unenv-runtime/npm/fsevents.mjs

@@ -0,0 +1,20 @@
+// https://www.npmjs.com/package/fsevents
+export default {
+	watch(_dir, _cb) {
+		return Promise.resolve();
+	},
+	getInfo(path, _flags, _id) {
+		return {
+			event: "mock",
+			path,
+			type: "file",
+			flags: 4294967296,
+			changes: {
+				inode: false,
+				finder: false,
+				access: false,
+				xattrs: false
+			}
+		};
+	}
+};

package/dist/polyfills/unenv-runtime/npm/inherits.d.mts

@@ -0,0 +1,2 @@
+import { inherits } from "node:util";
+export default inherits;

package/dist/polyfills/unenv-runtime/npm/inherits.mjs

@@ -0,0 +1,2 @@
+import { inherits } from "node:util";
+export default inherits;

package/dist/polyfills/unenv-runtime/npm/node-fetch.d.mts

@@ -0,0 +1,12 @@
+// https://github.com/node-fetch/node-fetch
+// Native browser APIs
+export declare const fetch: unknown;
+export declare const Headers: unknown;
+export declare const Request: unknown;
+export declare const Response: unknown;
+export declare const AbortController: unknown;
+// Error handling
+export declare const FetchError: unknown;
+export declare const AbortError: unknown;
+export declare const isRedirect: unknown;
+export default fetch;

package/dist/polyfills/unenv-runtime/npm/node-fetch.mjs

@@ -0,0 +1,23 @@
+// https://github.com/node-fetch/node-fetch
+// Native browser APIs
+export const fetch = (...args) => globalThis.fetch(...args);
+export const Headers = globalThis.Headers;
+export const Request = globalThis.Request;
+export const Response = globalThis.Response;
+export const AbortController = globalThis.AbortController;
+// Error handling
+export const FetchError = Error;
+export const AbortError = Error;
+// Top-level exported helpers (from node-fetch v3)
+const redirectStatus = new Set([
+	301,
+	302,
+	303,
+	307,
+	308
+]);
+export const isRedirect = (code) => redirectStatus.has(code);
+// node-fetch v2
+fetch.Promise = globalThis.Promise;
+fetch.isRedirect = isRedirect;
+export default fetch;

package/dist/polyfills/unenv-runtime/npm/whatwg-url/index.d.mts

@@ -0,0 +1,13 @@
+export declare const URL: unknown;
+export declare const URLSearchParams: unknown;
+export declare const parseURL: unknown;
+export declare const basicURLParse: unknown;
+export declare const serializeURL: unknown;
+export declare const serializeHost: unknown;
+export declare const serializeInteger: unknown;
+export declare const serializeURLOrigin: unknown;
+export declare const setTheUsername: unknown;
+export declare const setThePassword: unknown;
+export declare const cannotHaveAUsernamePasswordPort: unknown;
+export declare const percentDecodeBytes: unknown;
+export declare const percentDecodeString: unknown;

package/dist/polyfills/unenv-runtime/npm/whatwg-url/index.mjs

@@ -0,0 +1,15 @@
+// https://www.npmjs.com/package/whatwg-url
+import { notImplemented } from "../../_internal/utils.mjs";
+export const URL = globalThis.URL;
+export const URLSearchParams = globalThis.URLSearchParams;
+export const parseURL = /* @__PURE__ */ notImplemented("whatwg-url.parseURL");
+export const basicURLParse = /* @__PURE__ */ notImplemented("whatwg-url.basicURLParse");
+export const serializeURL = /* @__PURE__ */ notImplemented("whatwg-url.serializeURL");
+export const serializeHost = /* @__PURE__ */ notImplemented("whatwg-url.serializeHost");
+export const serializeInteger = /* @__PURE__ */ notImplemented("whatwg-url.serializeInteger");
+export const serializeURLOrigin = /* @__PURE__ */ notImplemented("whatwg-url.serializeURLOrigin");
+export const setTheUsername = /* @__PURE__ */ notImplemented("whatwg-url.setTheUsername");
+export const setThePassword = /* @__PURE__ */ notImplemented("whatwg-url.setThePassword");
+export const cannotHaveAUsernamePasswordPort = /* @__PURE__ */ notImplemented("whatwg-url.cannotHaveAUsernamePasswordPort");
+export const percentDecodeBytes = /* @__PURE__ */ notImplemented("whatwg-url.percentDecodeBytes");
+export const percentDecodeString = /* @__PURE__ */ notImplemented("whatwg-url.percentDecodeString");

package/dist/polyfills/unenv-runtime/npm/whatwg-url/webidl2js-wrapper.d.mts

@@ -0,0 +1,2 @@
+export declare const URL: unknown;
+export declare const URLSearchParams: unknown;

package/dist/polyfills/unenv-runtime/npm/whatwg-url/webidl2js-wrapper.mjs

@@ -0,0 +1,2 @@
+export const URL = globalThis.URL;
+export const URLSearchParams = globalThis.URLSearchParams;

package/dist/polyfills/unenv-runtime/polyfill/buffer.d.mts

@@ -0,0 +1 @@
+export {};

package/dist/polyfills/unenv-runtime/polyfill/buffer.mjs

@@ -0,0 +1,4 @@
+import { Buffer } from "node:buffer";
+if (!globalThis.Buffer) {
+	globalThis.Buffer = Buffer;
+}

package/dist/polyfills/unenv-runtime/polyfill/globalthis-global.d.mts

@@ -0,0 +1 @@
+export default globalThis;

package/dist/polyfills/unenv-runtime/polyfill/globalthis-global.mjs

@@ -0,0 +1,5 @@
+// Node.js compatibility
+if (!("global" in globalThis)) {
+	globalThis.global = globalThis;
+}
+export default globalThis;

package/dist/polyfills/unenv-runtime/polyfill/globalthis.d.mts

@@ -0,0 +1,2 @@
+// Injectable version of `globalThis.global` (without side effects)
+export default globalThis;

package/dist/polyfills/unenv-runtime/polyfill/globalthis.mjs

@@ -0,0 +1,2 @@
+// Injectable version of `globalThis.global` (without side effects)
+export default globalThis;

package/dist/polyfills/unenv-runtime/polyfill/package.json

@@ -0,0 +1,3 @@
+{
+  "sideEffects": true
+}

package/dist/polyfills/unenv-runtime/polyfill/performance.d.mts

@@ -0,0 +1,2 @@
+declare const _default;
+export default _default;

package/dist/polyfills/unenv-runtime/polyfill/performance.mjs

@@ -0,0 +1,10 @@
+import { performance, Performance, PerformanceEntry, PerformanceMark, PerformanceMeasure, PerformanceObserver, PerformanceObserverEntryList, PerformanceResourceTiming } from "../web/performance/index.mjs";
+globalThis.performance ||= performance;
+globalThis.Performance ||= Performance;
+globalThis.PerformanceEntry ||= PerformanceEntry;
+globalThis.PerformanceMark ||= PerformanceMark;
+globalThis.PerformanceMeasure ||= PerformanceMeasure;
+globalThis.PerformanceObserver ||= PerformanceObserver;
+globalThis.PerformanceObserverEntryList ||= PerformanceObserverEntryList;
+globalThis.PerformanceResourceTiming ||= PerformanceResourceTiming;
+export default globalThis.performance;

package/dist/polyfills/unenv-runtime/polyfill/process.d.mts

@@ -0,0 +1,2 @@
+declare const _default;
+export default _default;

package/dist/polyfills/unenv-runtime/polyfill/process.mjs

@@ -0,0 +1,10 @@
+import processModule from "node:process";
+// Keep a reference to the original process to avoid circular references after polyfilling
+const originalProcess = globalThis["process"];
+globalThis.process = originalProcess ? new Proxy(originalProcess, { get(target, prop, receiver) {
+	if (Reflect.has(target, prop)) {
+		return Reflect.get(target, prop, receiver);
+	}
+	return Reflect.get(processModule, prop, receiver);
+} }) : processModule;
+export default globalThis.process;

package/dist/polyfills/unenv-runtime/polyfill/source-maps.mjs

@@ -0,0 +1,15 @@
+// This polyfill enables `node --enable-source-maps` effect in supported Node.js versions (22.14+, 23.7+)
+// Docs: https://nodejs.org/api/module.html#modulesetsourcemapssupportenabled-options
+try {
+	const nodeModule = globalThis.process?.getBuiltinModule?.("node:module");
+	// @ts-expect-error TODO: update Node.js types
+	if (nodeModule && !nodeModule.getSourceMapsSupport?.()?.enabled) {
+		// @ts-expect-error
+		nodeModule.setSourceMapsSupport?.(true, {
+			generatedCode: true,
+			nodeModules: true
+		});
+	}
+} catch (error) {
+	console.warn("Failed to enable source maps support:", error);
+}

package/dist/polyfills/unenv-runtime/polyfill/timers.d.mts

@@ -0,0 +1 @@
+export {};

package/dist/polyfills/unenv-runtime/polyfill/timers.mjs

@@ -0,0 +1,7 @@
+import { setImmediate, clearImmediate } from "node:timers";
+if (!globalThis.setImmediate) {
+	globalThis.setImmediate = setImmediate;
+}
+if (!globalThis.clearImmediate) {
+	globalThis.clearImmediate = clearImmediate;
+}

package/dist/polyfills/unenv-runtime/web/performance/_polyfills.d.mts

@@ -0,0 +1,100 @@
+export type _PerformanceEntryType = "mark" | "measure" | "resource" | "event";
+// --------------------------------------
+// Performance entry polyfills
+// --------------------------------------
+// https://developer.mozilla.org/en-US/docs/Web/API/PerformanceObserver/supportedEntryTypes_static
+export declare const _supportedEntryTypes: _PerformanceEntryType[];
+// https://developer.mozilla.org/en-US/docs/Web/API/PerformanceEntry
+export declare class _PerformanceEntry implements globalThis.PerformanceEntry {
+	readonly __unenv__: true;
+	detail: any | undefined;
+	entryType: _PerformanceEntryType;
+	name: string;
+	startTime: number;
+	constructor(name: string, options?: PerformanceMarkOptions);
+	get duration(): number;
+	toJSON(): {};
+}
+// https://developer.mozilla.org/en-US/docs/Web/API/PerformanceMark
+export declare class _PerformanceMark extends _PerformanceEntry implements globalThis.PerformanceMark {
+	entryType: "mark";
+}
+// https://developer.mozilla.org/en-US/docs/Web/API/PerformanceMeasure
+export declare class _PerformanceMeasure extends _PerformanceEntry implements globalThis.PerformanceMeasure {
+	entryType: "measure";
+}
+// https://developer.mozilla.org/en-US/docs/Web/API/PerformanceResourceTiming
+export declare class _PerformanceResourceTiming extends _PerformanceEntry implements globalThis.PerformanceResourceTiming {
+	entryType: "resource";
+	serverTiming: readonly PerformanceServerTiming[];
+	connectEnd: number;
+	connectStart: number;
+	decodedBodySize: number;
+	domainLookupEnd: number;
+	domainLookupStart: number;
+	encodedBodySize: number;
+	fetchStart: number;
+	initiatorType: string;
+	name: string;
+	nextHopProtocol: string;
+	redirectEnd: number;
+	redirectStart: number;
+	requestStart: number;
+	responseEnd: number;
+	responseStart: number;
+	secureConnectionStart: number;
+	startTime: number;
+	transferSize: number;
+	workerStart: number;
+	responseStatus: number;
+}
+// --------------------------------------
+// PerformanceObserver polyfill
+// --------------------------------------
+// https://developer.mozilla.org/en-US/docs/Web/API/PerformanceObserver
+export declare class _PerformanceObserver implements globalThis.PerformanceObserver {
+	readonly __unenv__: true;
+	static supportedEntryTypes: ReadonlyArray<string>;
+	_callback: PerformanceObserverCallback | null;
+	constructor(callback: PerformanceObserverCallback);
+	takeRecords(): unknown;
+	disconnect(): void;
+	observe(options: PerformanceObserverInit): void;
+}
+// https://developer.mozilla.org/en-US/docs/Web/API/PerformanceObserverEntryList
+export declare class _PerformanceObserverEntryList implements globalThis.PerformanceObserverEntryList {
+	readonly __unenv__: true;
+	getEntries(): PerformanceEntryList;
+	getEntriesByName(_name: string, _type?: string | undefined): PerformanceEntryList;
+	getEntriesByType(type: string): PerformanceEntryList;
+}
+// --------------------------------------
+// Performance polyfill
+// --------------------------------------
+// https://developer.mozilla.org/en-US/docs/Web/API/Performance
+export declare class _Performance<PerformanceEntryT extends PerformanceEntry = PerformanceEntry> implements globalThis.Performance {
+	readonly __unenv__: true;
+	timeOrigin: number;
+	eventCounts: EventCounts;
+	_entries: PerformanceEntry[];
+	_resourceTimingBufferSize: number;
+	navigation: any;
+	timing: any;
+	onresourcetimingbufferfull: ((this: Performance, ev: Event) => any) | null;
+	now(): number;
+	clearMarks(markName?: string | undefined): void;
+	clearMeasures(measureName?: string | undefined): void;
+	clearResourceTimings(): void;
+	getEntries(): PerformanceEntryT[];
+	getEntriesByName(name: string, type?: string | undefined): PerformanceEntryT[];
+	getEntriesByType(type: string): PerformanceEntryT[];
+	mark(name: string, options?: PerformanceMarkOptions | undefined): PerformanceMark;
+	measure(measureName: string, startOrMeasureOptions?: string | PerformanceMeasureOptions, endMark?: string): PerformanceMeasure;
+	setResourceTimingBufferSize(maxSize: number): void;
+	toJSON();
+	addEventListener<K extends "resourcetimingbufferfull">(type: K, listener: (this: Performance, ev: PerformanceEventMap[K]) => any, options?: boolean | AddEventListenerOptions | undefined): void;
+	addEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | AddEventListenerOptions | undefined): void;
+	removeEventListener<K extends "resourcetimingbufferfull">(type: K, listener: (this: Performance, ev: PerformanceEventMap[K]) => any, options?: boolean | EventListenerOptions | undefined): void;
+	removeEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | EventListenerOptions | undefined): void;
+	dispatchEvent(event: Event): boolean;
+}

package/dist/polyfills/unenv-runtime/web/performance/_polyfills.mjs

@@ -0,0 +1,184 @@
+import { createNotImplementedError } from "../../_internal/utils.mjs";
+const _timeOrigin = globalThis.performance?.timeOrigin ?? Date.now();
+const _performanceNow = globalThis.performance?.now ? globalThis.performance.now.bind(globalThis.performance) : () => Date.now() - _timeOrigin;
+// --------------------------------------
+// Performance entry polyfills
+// --------------------------------------
+// https://developer.mozilla.org/en-US/docs/Web/API/PerformanceObserver/supportedEntryTypes_static
+export const _supportedEntryTypes = [
+	"event",
+	"mark",
+	"measure",
+	"resource"
+];
+// https://developer.mozilla.org/en-US/docs/Web/API/PerformanceEntry
+export class _PerformanceEntry {
+	__unenv__ = true;
+	detail;
+	entryType = "event";
+	name;
+	startTime;
+	constructor(name, options) {
+		this.name = name;
+		this.startTime = options?.startTime || _performanceNow();
+		this.detail = options?.detail;
+	}
+	get duration() {
+		return _performanceNow() - this.startTime;
+	}
+	toJSON() {
+		return {
+			name: this.name,
+			entryType: this.entryType,
+			startTime: this.startTime,
+			duration: this.duration,
+			detail: this.detail
+		};
+	}
+}
+// https://developer.mozilla.org/en-US/docs/Web/API/PerformanceMark
+export class _PerformanceMark extends _PerformanceEntry {
+	entryType = "mark";
+}
+// https://developer.mozilla.org/en-US/docs/Web/API/PerformanceMeasure
+export class _PerformanceMeasure extends _PerformanceEntry {
+	entryType = "measure";
+}
+// https://developer.mozilla.org/en-US/docs/Web/API/PerformanceResourceTiming
+export class _PerformanceResourceTiming extends _PerformanceEntry {
+	entryType = "resource";
+	serverTiming = [];
+	connectEnd = 0;
+	connectStart = 0;
+	decodedBodySize = 0;
+	domainLookupEnd = 0;
+	domainLookupStart = 0;
+	encodedBodySize = 0;
+	fetchStart = 0;
+	initiatorType = "";
+	name = "";
+	nextHopProtocol = "";
+	redirectEnd = 0;
+	redirectStart = 0;
+	requestStart = 0;
+	responseEnd = 0;
+	responseStart = 0;
+	secureConnectionStart = 0;
+	startTime = 0;
+	transferSize = 0;
+	workerStart = 0;
+	responseStatus = 0;
+}
+// --------------------------------------
+// PerformanceObserver polyfill
+// --------------------------------------
+// https://developer.mozilla.org/en-US/docs/Web/API/PerformanceObserver
+export class _PerformanceObserver {
+	__unenv__ = true;
+	static supportedEntryTypes = _supportedEntryTypes;
+	_callback = null;
+	constructor(callback) {
+		this._callback = callback;
+	}
+	takeRecords() {
+		return [];
+	}
+	disconnect() {
+		throw createNotImplementedError("PerformanceObserver.disconnect");
+	}
+	observe(options) {
+		throw createNotImplementedError("PerformanceObserver.observe");
+	}
+}
+// https://developer.mozilla.org/en-US/docs/Web/API/PerformanceObserverEntryList
+export class _PerformanceObserverEntryList {
+	__unenv__ = true;
+	getEntries() {
+		return [];
+	}
+	getEntriesByName(_name, _type) {
+		return [];
+	}
+	getEntriesByType(type) {
+		return [];
+	}
+}
+// --------------------------------------
+// Performance polyfill
+// --------------------------------------
+// https://developer.mozilla.org/en-US/docs/Web/API/Performance
+export class _Performance {
+	__unenv__ = true;
+	timeOrigin = _timeOrigin;
+	eventCounts = new Map();
+	_entries = [];
+	_resourceTimingBufferSize = 0;
+	navigation = undefined;
+	timing = undefined;
+	onresourcetimingbufferfull = null;
+	now() {
+		// https://developer.mozilla.org/en-US/docs/Web/API/Performance/now
+		if (this.timeOrigin === _timeOrigin) {
+			return _performanceNow();
+		}
+		return Date.now() - this.timeOrigin;
+	}
+	clearMarks(markName) {
+		this._entries = markName ? this._entries.filter((e) => e.name !== markName) : this._entries.filter((e) => e.entryType !== "mark");
+	}
+	clearMeasures(measureName) {
+		this._entries = measureName ? this._entries.filter((e) => e.name !== measureName) : this._entries.filter((e) => e.entryType !== "measure");
+	}
+	clearResourceTimings() {
+		this._entries = this._entries.filter((e) => e.entryType !== "resource" || e.entryType !== "navigation");
+	}
+	getEntries() {
+		return this._entries;
+	}
+	getEntriesByName(name, type) {
+		return this._entries.filter((e) => e.name === name && (!type || e.entryType === type));
+	}
+	getEntriesByType(type) {
+		return this._entries.filter((e) => e.entryType === type);
+	}
+	mark(name, options) {
+		const entry = new _PerformanceMark(name, options);
+		this._entries.push(entry);
+		return entry;
+	}
+	measure(measureName, startOrMeasureOptions, endMark) {
+		let start;
+		let end;
+		if (typeof startOrMeasureOptions === "string") {
+			start = this.getEntriesByName(startOrMeasureOptions, "mark")[0]?.startTime;
+			end = this.getEntriesByName(endMark, "mark")[0]?.startTime;
+		} else {
+			start = Number.parseFloat(startOrMeasureOptions?.start) || this.now();
+			end = Number.parseFloat(startOrMeasureOptions?.end) || this.now();
+		}
+		const entry = new _PerformanceMeasure(measureName, {
+			startTime: start,
+			detail: {
+				start,
+				end
+			}
+		});
+		this._entries.push(entry);
+		return entry;
+	}
+	setResourceTimingBufferSize(maxSize) {
+		this._resourceTimingBufferSize = maxSize;
+	}
+	toJSON() {
+		return this;
+	}
+	addEventListener(type, listener, options) {
+		throw createNotImplementedError("Performance.addEventListener");
+	}
+	removeEventListener(type, listener, options) {
+		throw createNotImplementedError("Performance.removeEventListener");
+	}
+	dispatchEvent(event) {
+		throw createNotImplementedError("Performance.dispatchEvent");
+	}
+}

package/dist/polyfills/unenv-runtime/web/performance/index.d.mts

@@ -0,0 +1,12 @@
+export { type _PerformanceEntryType, _PerformanceEntry, _PerformanceMark, _PerformanceMeasure, _PerformanceResourceTiming, _Performance, _PerformanceObserver, _PerformanceObserverEntryList } from "./_polyfills.mjs";
+export declare const PerformanceEntry: typeof globalThis.PerformanceEntry;
+export declare const PerformanceMark: typeof globalThis.PerformanceMark;
+export declare const PerformanceMeasure: typeof globalThis.PerformanceMeasure;
+export declare const PerformanceResourceTiming: typeof globalThis.PerformanceResourceTiming;
+export declare const PerformanceObserver: typeof globalThis.PerformanceObserver;
+export declare const Performance: typeof globalThis.Performance;
+export declare const PerformanceObserverEntryList: typeof globalThis.PerformanceObserverEntryList;
+// workerd implements a subset of globalThis.performance (as of last check, only timeOrigin set to 0 + now() implemented)
+// We already use performance.now() from globalThis.performance, if provided (see top of this file)
+// If we detect this condition, we can just use polyfill instead.
+export declare const performance: unknown;

package/dist/polyfills/unenv-runtime/web/performance/index.mjs

@@ -0,0 +1,14 @@
+// https://developer.mozilla.org/en-US/docs/Web/API/Performance_API
+import { _PerformanceEntry, _PerformanceMark, _PerformanceMeasure, _PerformanceResourceTiming, _Performance, _PerformanceObserver, _PerformanceObserverEntryList } from "./_polyfills.mjs";
+export { _PerformanceEntry, _PerformanceMark, _PerformanceMeasure, _PerformanceResourceTiming, _Performance, _PerformanceObserver, _PerformanceObserverEntryList } from "./_polyfills.mjs";
+export const PerformanceEntry = globalThis.PerformanceEntry || _PerformanceEntry;
+export const PerformanceMark = globalThis.PerformanceMark || _PerformanceMark;
+export const PerformanceMeasure = globalThis.PerformanceMeasure || _PerformanceMeasure;
+export const PerformanceResourceTiming = globalThis.PerformanceResourceTiming || _PerformanceResourceTiming;
+export const PerformanceObserver = globalThis.PerformanceObserver || _PerformanceObserver;
+export const Performance = globalThis.Performance || _Performance;
+export const PerformanceObserverEntryList = globalThis.PerformanceObserverEntryList || _PerformanceObserverEntryList;
+// workerd implements a subset of globalThis.performance (as of last check, only timeOrigin set to 0 + now() implemented)
+// We already use performance.now() from globalThis.performance, if provided (see top of this file)
+// If we detect this condition, we can just use polyfill instead.
+export const performance = globalThis.performance && "addEventListener" in globalThis.performance ? globalThis.performance : new _Performance();

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@capsule-run/sdk",
-  "version": "0.8.3",
+  "version": "0.8.5",
   "description": "Capsule JavaScript SDK - run AI agent tasks in secure WASM sandboxes",
   "type": "module",
   "main": "./dist/index.js",
@@ -30,7 +30,7 @@
     "README.md"
   ],
   "scripts": {
-    "build": "tsc",
+    "build": "tsc && node scripts/copy-unenv-polyfills.mjs",
     "clean": "rm -rf dist"
   },
   "keywords": [