@telemetry-dev/sdk 0.1.0

package/dist/index.mjs

@@ -0,0 +1,558 @@
+import { INVALID_SPAN_CONTEXT, ROOT_CONTEXT, SpanKind, SpanStatusCode, context, defaultTextMapSetter, propagation, trace } from "@opentelemetry/api";
+import { W3CTraceContextPropagator, parseTraceParent } from "@opentelemetry/core";
+import { resourceFromAttributes } from "@opentelemetry/resources";
+import { BatchLogRecordProcessor, LoggerProvider, SimpleLogRecordProcessor } from "@opentelemetry/sdk-logs";
+import { BasicTracerProvider } from "@opentelemetry/sdk-trace-base";
+import { AlsContextManager, BATCHED_METRIC_INTERVAL_MS, DEFAULT_BASE_URL, DEFAULT_BATCH, DORMANT_INTERVAL_MS, PROPAGATED_KEY, SCOPE_NAME, SCOPE_VERSION, StampingSpanProcessor, activeContext, als, createLogExporter, createMetricExporter, createMetricsPipeline, createTraceExporter, diag, jsonAttr, omitUndefined, otlpHeaders, propagateAttributes, propagatedFromContext, reportError, resolveEnv, setLogLevel, withContext } from "@telemetry-dev/otel";
+import { SeverityNumber } from "@opentelemetry/api-logs";
+function resolveConfig(options = {}) {
+	const env = resolveEnv();
+	const baseUrl = (options.baseUrl ?? env.TELEMETRY_DEV_BASE_URL ?? DEFAULT_BASE_URL).replace(/\/+$/, "");
+	return {
+		apiKey: options.apiKey ?? env.TELEMETRY_DEV_API_KEY,
+		baseUrl,
+		environment: options.environment ?? env.TELEMETRY_DEV_ENVIRONMENT ?? "production",
+		serviceName: options.serviceName ?? env.OTEL_SERVICE_NAME ?? "unknown_service",
+		enabled: options.enabled ?? true,
+		registerGlobal: options.registerGlobal ?? false,
+		exportMode: options.exportMode ?? "batched",
+		captureInput: options.captureInput ?? true,
+		captureOutput: options.captureOutput ?? true,
+		mask: options.mask,
+		maxAttributeLength: options.maxAttributeLength ?? 65536,
+		batch: {
+			...DEFAULT_BATCH,
+			...options.batch
+		},
+		spanFilter: options.spanFilter,
+		resourceAttributes: options.resourceAttributes,
+		logLevel: options.logLevel ?? "warn",
+		fetchImpl: options.fetch ?? globalThis.fetch,
+		waitUntil: options.waitUntil,
+		onError: options.onError
+	};
+}
+//#endregion
+//#region src/client.ts
+const NOOP_CLIENT = {
+	enabled: false,
+	flush: () => Promise.resolve(),
+	shutdown: () => Promise.resolve()
+};
+let activeClient;
+function currentClient() {
+	return activeClient ?? NOOP_CLIENT;
+}
+function flush() {
+	return currentClient().flush();
+}
+function shutdown() {
+	return currentClient().shutdown();
+}
+function init(options, overrides) {
+	try {
+		return initInner(options, overrides);
+	} catch (error) {
+		reportError(options?.onError, error);
+		activeClient = NOOP_CLIENT;
+		return NOOP_CLIENT;
+	}
+}
+function initInner(options, overrides) {
+	const config = resolveConfig(options);
+	setLogLevel(config.logLevel);
+	if (activeClient && activeClient !== NOOP_CLIENT) {
+		diag.warn("init() called again; replacing the previous client");
+		activeClient.shutdown().catch((error) => reportError(config.onError, error));
+	}
+	if (!(config.enabled && Boolean(config.apiKey ?? overrides?.spanExporter))) {
+		if (config.enabled && !config.apiKey) diag.debug("no api key (apiKey option or TELEMETRY_DEV_API_KEY); telemetry disabled");
+		activeClient = NOOP_CLIENT;
+		return NOOP_CLIENT;
+	}
+	const resource = resourceFromAttributes({
+		"service.name": config.serviceName,
+		"deployment.environment.name": config.environment,
+		...config.resourceAttributes
+	});
+	const transport = {
+		fetchImpl: config.fetchImpl,
+		onError: config.onError
+	};
+	const headers = config.apiKey ? otlpHeaders(config.apiKey) : void 0;
+	const spanExporter = overrides?.spanExporter ?? createTraceExporter({
+		url: `${config.baseUrl}/v1/traces`,
+		headers
+	}, transport);
+	const metricExporter = overrides?.metricExporter ?? (headers ? createMetricExporter({
+		url: `${config.baseUrl}/v1/metrics`,
+		headers
+	}, transport) : void 0);
+	const metrics = metricExporter ? createMetricsPipeline({
+		resource,
+		exporter: metricExporter,
+		exportIntervalMillis: config.exportMode === "batched" ? BATCHED_METRIC_INTERVAL_MS : DORMANT_INTERVAL_MS
+	}) : void 0;
+	const spanFilter = config.spanFilter ?? (config.registerGlobal ? (span) => span.instrumentationScope.name === SCOPE_NAME : void 0);
+	const provider = new BasicTracerProvider({
+		resource,
+		spanProcessors: [new StampingSpanProcessor({
+			exporter: spanExporter,
+			exportMode: config.exportMode,
+			batch: config.batch,
+			spanFilter,
+			recordMetrics: metrics ? (span) => metrics.record(span) : void 0,
+			onError: config.onError
+		})],
+		spanLimits: { attributeValueLengthLimit: config.maxAttributeLength }
+	});
+	const tracer = provider.getTracer(SCOPE_NAME, SCOPE_VERSION);
+	let registeredTrace = false;
+	let registeredContext = false;
+	let registeredPropagation = false;
+	if (config.registerGlobal) {
+		registeredTrace = trace.setGlobalTracerProvider(provider);
+		if (als) registeredContext = context.setGlobalContextManager(new AlsContextManager(als));
+		registeredPropagation = propagation.setGlobalPropagator(new W3CTraceContextPropagator());
+		if (!registeredTrace) diag.warn("a global TracerProvider is already registered; attach the TelemetrySpanProcessor from '@telemetry-dev/otel' to your own provider instead");
+	}
+	const logExporter = overrides?.logRecordExporter ?? (headers ? createLogExporter({
+		url: `${config.baseUrl}/v1/logs`,
+		headers
+	}, transport) : void 0);
+	let logs;
+	const ensureLogger = () => {
+		if (!logExporter) return void 0;
+		if (!logs) {
+			const logProcessor = config.exportMode === "immediate" ? new SimpleLogRecordProcessor(logExporter) : new BatchLogRecordProcessor(logExporter);
+			const loggerProvider = new LoggerProvider({
+				resource,
+				logRecordLimits: { attributeValueLengthLimit: config.maxAttributeLength },
+				processors: [logProcessor]
+			});
+			logs = {
+				logger: loggerProvider.getLogger(SCOPE_NAME, SCOPE_VERSION),
+				forceFlush: () => loggerProvider.forceFlush(),
+				shutdown: () => loggerProvider.shutdown()
+			};
+		}
+		return logs.logger;
+	};
+	let torn = false;
+	const collect = (op) => {
+		const parts = [provider[op]()];
+		if (logs) parts.push(logs[op]());
+		if (metrics) parts.push(metrics[op]());
+		return Promise.all(parts).then(() => void 0).catch((error) => reportError(config.onError, error));
+	};
+	const handoff = (p) => {
+		if (config.waitUntil) {
+			config.waitUntil(p);
+			return Promise.resolve();
+		}
+		return p;
+	};
+	const handle = {
+		get enabled() {
+			return !torn;
+		},
+		flush: () => torn ? Promise.resolve() : handoff(collect("forceFlush")),
+		shutdown: () => {
+			if (torn) return Promise.resolve();
+			torn = true;
+			if (registeredTrace) trace.disable();
+			if (registeredContext) context.disable();
+			if (registeredPropagation) propagation.disable();
+			handle.core = void 0;
+			return handoff(collect("shutdown"));
+		}
+	};
+	handle.core = {
+		config,
+		tracer,
+		ensureLogger
+	};
+	activeClient = handle;
+	return handle;
+}
+//#endregion
+//#region src/capture.ts
+const TRUNCATION_MARKER = "...[truncated]";
+function truncate(value, maxLength) {
+	if (value.length <= maxLength) return value;
+	return value.slice(0, Math.max(maxLength - 14, 0)) + TRUNCATION_MARKER;
+}
+/** The single content funnel: mask → JSON stringify → truncate. */
+function prepareCaptureValue(key, value, cfg) {
+	let masked = value;
+	if (cfg.mask) try {
+		masked = cfg.mask(value, { key });
+	} catch (error) {
+		reportError(cfg.onError, error);
+		return;
+	}
+	const serialized = jsonAttr(masked);
+	if (serialized === void 0) return void 0;
+	return truncate(serialized, cfg.maxAttributeLength);
+}
+//#endregion
+//#region src/logs.ts
+const SEVERITIES = {
+	debug: {
+		number: SeverityNumber.DEBUG,
+		text: "DEBUG"
+	},
+	info: {
+		number: SeverityNumber.INFO,
+		text: "INFO"
+	},
+	warn: {
+		number: SeverityNumber.WARN,
+		text: "WARN"
+	},
+	error: {
+		number: SeverityNumber.ERROR,
+		text: "ERROR"
+	}
+};
+/**
+* Emit a log record to /v1/logs, correlated to the active span (when any) and stamped with the
+* propagated correlation attributes. Works inside and outside spans.
+*/
+function log(message, options) {
+	const core = currentClient().core;
+	if (!core) return;
+	try {
+		const logger = core.ensureLogger();
+		if (!logger) return;
+		const cfg = core.config;
+		const captureCfg = {
+			mask: cfg.mask,
+			maxAttributeLength: cfg.maxAttributeLength,
+			onError: cfg.onError
+		};
+		const severity = SEVERITIES[options?.level ?? "info"];
+		const ctx = activeContext();
+		const attributes = {};
+		for (const [key, value] of Object.entries(options?.attributes ?? {})) {
+			if (value === void 0) continue;
+			if (typeof value === "number" || typeof value === "boolean") {
+				attributes[key] = value;
+				continue;
+			}
+			const prepared = prepareCaptureValue(key, value, captureCfg);
+			if (prepared !== void 0) attributes[key] = prepared;
+		}
+		const propagated = propagatedFromContext(ctx);
+		if (propagated) {
+			for (const [key, value] of Object.entries(propagated)) if (value !== void 0) attributes[key] = typeof value === "string" ? truncate(value, cfg.maxAttributeLength) : value;
+		}
+		logger.emit({
+			body: prepareCaptureValue("log.message", message, captureCfg) ?? "",
+			severityNumber: severity.number,
+			severityText: severity.text,
+			eventName: options?.eventName,
+			timestamp: options?.timestamp,
+			context: ctx,
+			attributes
+		});
+	} catch (error) {
+		reportError(core.config.onError, error);
+	}
+}
+//#endregion
+//#region src/attrs.ts
+const SPAN_TYPE_OPERATIONS = {
+	span: "function",
+	generation: "chat",
+	tool: "execute_tool",
+	agent: "invoke_agent",
+	embedding: "embeddings"
+};
+function inputKeyFor(type) {
+	return type === "tool" ? "gen_ai.tool.call.arguments" : "gen_ai.input.messages";
+}
+function outputKeyFor(type) {
+	return type === "tool" ? "gen_ai.tool.call.result" : "gen_ai.output.messages";
+}
+const RESERVED_METADATA_KEYS = new Set([
+	"userId",
+	"sessionId",
+	"user_id",
+	"session_id"
+]);
+function fieldsToAttributes(fields, type, cfg) {
+	const attrs = omitUndefined({
+		"gen_ai.request.model": fields.model,
+		"gen_ai.provider.name": fields.provider,
+		"gen_ai.response.model": fields.responseModel,
+		"gen_ai.response.id": fields.responseId,
+		"gen_ai.usage.input_tokens": fields.usage?.inputTokens,
+		"gen_ai.usage.output_tokens": fields.usage?.outputTokens,
+		"gen_ai.usage.total_tokens": fields.usage?.totalTokens,
+		"gen_ai.usage.cache_read.input_tokens": fields.usage?.cacheReadInputTokens,
+		"gen_ai.usage.cache_creation.input_tokens": fields.usage?.cacheCreationInputTokens,
+		"gen_ai.usage.reasoning.output_tokens": fields.usage?.reasoningOutputTokens,
+		"gen_ai.usage.cost": fields.costUsd,
+		"gen_ai.response.finish_reasons": fields.finishReason ? [fields.finishReason] : void 0,
+		"gen_ai.output.type": fields.outputType,
+		"gen_ai.request.temperature": fields.temperature,
+		"gen_ai.request.top_p": fields.topP,
+		"gen_ai.request.top_k": fields.topK,
+		"gen_ai.request.max_tokens": fields.maxTokens,
+		"gen_ai.request.stop_sequences": fields.stopSequences,
+		"gen_ai.request.seed": fields.seed,
+		"gen_ai.request.frequency_penalty": fields.frequencyPenalty,
+		"gen_ai.request.presence_penalty": fields.presencePenalty,
+		"gen_ai.response.time_to_first_chunk": fields.timeToFirstChunkMs !== void 0 ? fields.timeToFirstChunkMs / 1e3 : void 0,
+		"gen_ai.tool.name": fields.toolName,
+		"gen_ai.tool.call.id": fields.toolCallId,
+		"gen_ai.tool.description": fields.toolDescription,
+		"gen_ai.agent.name": fields.agentName,
+		"gen_ai.agent.id": fields.agentId
+	});
+	if (fields.systemInstructions !== void 0 && cfg.captureInput) {
+		const value = prepareCaptureValue("gen_ai.system_instructions", fields.systemInstructions, cfg);
+		if (value !== void 0) attrs["gen_ai.system_instructions"] = value;
+	}
+	if (fields.input !== void 0 && cfg.captureInput) {
+		const key = inputKeyFor(type);
+		const value = prepareCaptureValue(key, fields.input, cfg);
+		if (value !== void 0) attrs[key] = value;
+	}
+	if (fields.output !== void 0 && cfg.captureOutput) {
+		const key = outputKeyFor(type);
+		const value = prepareCaptureValue(key, fields.output, cfg);
+		if (value !== void 0) attrs[key] = value;
+	}
+	if (fields.metadata) for (const [key, value] of Object.entries(fields.metadata)) {
+		if (RESERVED_METADATA_KEYS.has(key)) {
+			diag.debug(`metadata key "${key}" is reserved; pass it via propagateAttributes instead`);
+			continue;
+		}
+		const attr = typeof value === "string" ? value : jsonAttr(value);
+		if (attr !== void 0) attrs[`td.metadata.${key}`] = truncate(attr, cfg.maxAttributeLength);
+	}
+	if (fields.attributes) Object.assign(attrs, omitUndefined(fields.attributes));
+	return attrs;
+}
+//#endregion
+//#region src/noop.ts
+const noopSpan = trace.wrapSpanContext(INVALID_SPAN_CONTEXT);
+/** Shared inert handle returned by span primitives before init() or when disabled. */
+const NOOP_SPAN_HANDLE = {
+	span: noopSpan,
+	context: trace.setSpan(ROOT_CONTEXT, noopSpan),
+	traceId: INVALID_SPAN_CONTEXT.traceId,
+	spanId: INVALID_SPAN_CONTEXT.spanId,
+	traceparent: null,
+	isRecording: false,
+	update: () => NOOP_SPAN_HANDLE,
+	end: () => {}
+};
+//#endregion
+//#region src/span.ts
+const SPAN_META = /* @__PURE__ */ new WeakMap();
+const SEVERITY_ERROR = 17;
+function isThenable(value) {
+	return value != null && (typeof value === "object" || typeof value === "function") && "then" in value && typeof value.then === "function";
+}
+function isContext(value) {
+	return "getValue" in value && typeof value.getValue === "function";
+}
+function isSpanHandle(value) {
+	return "span" in value && "context" in value && "update" in value;
+}
+function withAmbientPropagated(ctx) {
+	if (propagatedFromContext(ctx)) return ctx;
+	const ambient = propagatedFromContext(activeContext());
+	return ambient ? ctx.setValue(PROPAGATED_KEY, ambient) : ctx;
+}
+function resolveParent(parent) {
+	const base = activeContext();
+	if (parent === void 0) return base;
+	if (typeof parent === "string") {
+		const parsed = parseTraceParent(parent);
+		if (!parsed) return base;
+		return trace.setSpanContext(base, {
+			...parsed,
+			isRemote: true
+		});
+	}
+	if (isSpanHandle(parent)) return withAmbientPropagated(parent.context);
+	if (isContext(parent)) return withAmbientPropagated(parent);
+	return trace.setSpanContext(base, parent);
+}
+function applyError(span, error) {
+	const err = error instanceof Error ? error : void 0;
+	const errorType = err?.name ?? "Error";
+	const message = err?.message ?? String(error);
+	span.setStatus({ code: SpanStatusCode.ERROR });
+	span.setAttribute("error.type", errorType);
+	span.addEvent("exception", omitUndefined({
+		"exception.type": errorType,
+		"exception.message": message,
+		"exception.stacktrace": err?.stack,
+		"log.severity_number": SEVERITY_ERROR
+	}));
+}
+function applyFields(span, meta, fields) {
+	if (fields.name) span.updateName(fields.name);
+	const attrs = fieldsToAttributes(fields, meta.type, meta.capture);
+	if (Object.keys(attrs).length > 0) span.setAttributes(attrs);
+	if (fields.error !== void 0) applyError(span, fields.error);
+}
+function metaFor(core, options) {
+	const cfg = core.config;
+	return {
+		type: options?.type ?? "span",
+		capture: {
+			mask: cfg.mask,
+			maxAttributeLength: cfg.maxAttributeLength,
+			onError: cfg.onError,
+			captureInput: options?.captureInput ?? cfg.captureInput,
+			captureOutput: options?.captureOutput ?? cfg.captureOutput
+		},
+		onError: cfg.onError
+	};
+}
+function createSpanHandle(core, name, options = {}) {
+	const meta = metaFor(core, options);
+	const parentCtx = resolveParent(options.parent);
+	const span = core.tracer.startSpan(name, {
+		kind: SpanKind.INTERNAL,
+		startTime: options.startTime,
+		attributes: { "gen_ai.operation.name": SPAN_TYPE_OPERATIONS[meta.type] }
+	}, parentCtx);
+	SPAN_META.set(span, meta);
+	applyFields(span, meta, options);
+	const spanContext = span.spanContext();
+	const flags = (spanContext.traceFlags & 255).toString(16).padStart(2, "0");
+	const handle = {
+		span,
+		context: trace.setSpan(parentCtx, span),
+		traceId: spanContext.traceId,
+		spanId: spanContext.spanId,
+		traceparent: `00-${spanContext.traceId}-${spanContext.spanId}-${flags}`,
+		get isRecording() {
+			return span.isRecording();
+		},
+		update(fields) {
+			try {
+				applyFields(span, meta, fields);
+			} catch (error) {
+				reportError(meta.onError, error);
+			}
+			return handle;
+		},
+		end(fields) {
+			try {
+				if (fields) applyFields(span, meta, fields);
+			} catch (error) {
+				reportError(meta.onError, error);
+			}
+			span.end(fields?.endTime);
+		}
+	};
+	return handle;
+}
+/** Start a span WITHOUT activating context; the caller must call .end(). */
+function startSpan(name, options) {
+	const core = currentClient().core;
+	if (!core) return NOOP_SPAN_HANDLE;
+	try {
+		return createSpanHandle(core, name, options);
+	} catch (error) {
+		reportError(core.config.onError, error);
+		return NOOP_SPAN_HANDLE;
+	}
+}
+function runWithHandle(handle, fn) {
+	try {
+		const result = withContext(handle.context, () => fn(handle));
+		if (isThenable(result)) return result.then((value) => {
+			handle.end();
+			return value;
+		}, (error) => {
+			handle.end({ error });
+			throw error;
+		});
+		handle.end();
+		return result;
+	} catch (error) {
+		handle.end({ error });
+		throw error;
+	}
+}
+function startActiveSpan(name, optionsOrFn, maybeFn) {
+	const fn = typeof optionsOrFn === "function" ? optionsOrFn : maybeFn;
+	const handle = startSpan(name, typeof optionsOrFn === "function" ? void 0 : optionsOrFn);
+	if (!handle.isRecording) return fn(handle);
+	return runWithHandle(handle, fn);
+}
+/** Update the innermost active span; no-op when none is recording. */
+function updateActiveSpan(fields) {
+	const core = currentClient().core;
+	if (!core) return;
+	try {
+		const span = trace.getSpan(activeContext());
+		if (!span?.isRecording()) return;
+		applyFields(span, SPAN_META.get(span) ?? metaFor(core), fields);
+	} catch (error) {
+		reportError(core.config.onError, error);
+	}
+}
+const PROPAGATOR = new W3CTraceContextPropagator();
+/** Serialize the active span context as a W3C traceparent; null when there is none. */
+function getTraceparent() {
+	const carrier = {};
+	PROPAGATOR.inject(activeContext(), carrier, defaultTextMapSetter);
+	return carrier.traceparent ?? null;
+}
+//#endregion
+//#region src/observe.ts
+/**
+* Wrap a function (sync or async) so every call becomes a span: args → input, return value →
+* output, thrown/rejected errors captured and rethrown. Activates context so nested SDK calls
+* parent to it. Resolves the client at call time, so wrapping at module load before init() works.
+*/
+function observe(fn, options) {
+	const wrapped = function(...args) {
+		const core = currentClient().core;
+		if (!core) return fn.apply(this, args);
+		let handle;
+		try {
+			const name = options?.name ?? (fn.name || "anonymous");
+			const input = options?.input !== void 0 ? options.input : args.length === 0 ? void 0 : args.length === 1 ? args[0] : args;
+			handle = createSpanHandle(core, name, {
+				...options,
+				input
+			});
+		} catch (error) {
+			reportError(core.config.onError, error);
+			return fn.apply(this, args);
+		}
+		try {
+			const result = withContext(handle.context, () => fn.apply(this, args));
+			if (isThenable(result)) return result.then((value) => {
+				handle.end({ output: value });
+				return value;
+			}, (error) => {
+				handle.end({ error });
+				throw error;
+			});
+			handle.end({ output: result });
+			return result;
+		} catch (error) {
+			handle.end({ error });
+			throw error;
+		}
+	};
+	Object.defineProperty(wrapped, "name", {
+		value: fn.name || "anonymous",
+		configurable: true
+	});
+	return wrapped;
+}
+//#endregion
+export { flush, getTraceparent, init, log, observe, propagateAttributes, shutdown, startActiveSpan, startSpan, updateActiveSpan };

package/package.json

@@ -0,0 +1,67 @@
+{
+  "name": "@telemetry-dev/sdk",
+  "version": "0.1.0",
+  "description": "Pure TypeScript SDK for telemetry.dev: LLM traces, logs, and GenAI metrics on OpenTelemetry, for Node and edge runtimes.",
+  "keywords": [
+    "genai",
+    "llm",
+    "observability",
+    "opentelemetry",
+    "otel",
+    "sdk",
+    "telemetry",
+    "tracing"
+  ],
+  "homepage": "https://telemetry.dev",
+  "license": "MIT",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/telemetry-dev/telemetry.dev.git",
+    "directory": "packages/sdk"
+  },
+  "files": [
+    "dist",
+    "src"
+  ],
+  "type": "module",
+  "exports": {
+    ".": {
+      "types": "./dist/index.d.mts",
+      "import": "./dist/index.mjs",
+      "default": "./dist/index.mjs"
+    },
+    "./package.json": "./package.json"
+  },
+  "publishConfig": {
+    "access": "public"
+  },
+  "dependencies": {
+    "@opentelemetry/api-logs": "^0.218.0",
+    "@opentelemetry/core": "^2.7.1",
+    "@opentelemetry/resources": "^2.7.1",
+    "@opentelemetry/sdk-logs": "^0.218.0",
+    "@opentelemetry/sdk-metrics": "^2.7.1",
+    "@opentelemetry/sdk-trace-base": "^2.7.1",
+    "@telemetry-dev/otel": "^0.1.0"
+  },
+  "devDependencies": {
+    "@opentelemetry/api": "^1.9.1",
+    "@types/node": "^25.5.0",
+    "@typescript/native-preview": "7.0.0-dev.20260328.1",
+    "typescript": "^6.0.2",
+    "vite-plus": "0.1.20",
+    "vitest": "npm:@voidzero-dev/vite-plus-test@0.1.20"
+  },
+  "peerDependencies": {
+    "@opentelemetry/api": ">=1.9.0 <2"
+  },
+  "engines": {
+    "node": ">=20.19.0"
+  },
+  "scripts": {
+    "build": "pnpm exec vp pack",
+    "dev": "pnpm exec vp pack --watch",
+    "test": "vp test",
+    "check": "vp check"
+  }
+}