@zgeoff/imp-client 0.0.0

package/dist/index.js

@@ -0,0 +1,678 @@
+import { ORPCError, ORPCError as ORPCError$1, createORPCClient, isDefinedError, safe } from "@orpc/client";
+import { RPCLink } from "@orpc/client/fetch";
+import * as z from "zod";
+//#endregion
+//#region src/check-server.ts
+const CLIENT_VERSION = "0.0.0";
+async function checkServer(rpc) {
+	const info = await rpc.system.info();
+	return {
+		clientVersion: CLIENT_VERSION,
+		serverVersion: info.version,
+		compatible: isCompatibleVersion(CLIENT_VERSION, info.version)
+	};
+}
+function isCompatibleVersion(client, server) {
+	const ours = parseVersion(client);
+	const theirs = parseVersion(server);
+	if (ours === null || theirs === null || ours.major !== theirs.major) return false;
+	return ours.major > 0 || ours.minor === theirs.minor;
+}
+function parseVersion(version) {
+	const groups = /^(?<major>\d+)\.(?<minor>\d+)\.\d+/.exec(version)?.groups;
+	return groups === void 0 ? null : {
+		major: Number(groups["major"]),
+		minor: Number(groups["minor"])
+	};
+}
+//#endregion
+//#region ../api/src/name-schema.ts
+const NameSchema = z.string().regex(/^[a-z][a-z0-9-]{0,30}$/, "must be a lowercase letter followed by up to 30 lowercase letters, digits or hyphens");
+//#endregion
+//#region ../api/src/session-schema.ts
+const SessionNameSchema = z.string().regex(/^[a-z0-9][a-z0-9-]{0,31}$/, "must be a lowercase letter or digit followed by up to 31 lowercase letters, digits or hyphens");
+const SessionExitSchema = z.object({
+	code: z.int().nullable(),
+	signal: z.string().nullable()
+}).readonly();
+z.object({
+	name: SessionNameSchema,
+	pid: z.int().positive(),
+	argv: z.array(z.string()).readonly(),
+	state: z.enum(["running", "exited"]),
+	attached: z.boolean(),
+	cols: z.int().positive(),
+	rows: z.int().positive(),
+	startedAt: z.date(),
+	exit: SessionExitSchema.optional()
+});
+//#endregion
+//#region ../api/src/exec-protocol.ts
+const EXEC_PATH = "/exec";
+const EXEC_TICKET_PARAM = "ticket";
+const EXEC_CHANNELS = {
+	stdin: 0,
+	stdout: 1,
+	stderr: 2
+};
+const DimensionSchema = z.int().min(1).max(65535);
+const ExecStartMessageSchema = z.object({
+	type: z.literal("start"),
+	name: NameSchema,
+	argv: z.array(z.string()).min(1),
+	env: z.record(z.string(), z.string()).optional(),
+	cwd: z.string().optional(),
+	tty: z.boolean(),
+	cols: DimensionSchema.optional(),
+	rows: DimensionSchema.optional(),
+	session: SessionNameSchema.optional()
+}).refine((start) => start.session === void 0 || start.tty, {
+	message: "a session needs a tty",
+	path: ["tty"]
+});
+const ExecAttachMessageSchema = z.object({
+	type: z.literal("attach"),
+	name: NameSchema,
+	session: SessionNameSchema,
+	cols: DimensionSchema.optional(),
+	rows: DimensionSchema.optional()
+});
+z.discriminatedUnion("type", [
+	ExecStartMessageSchema,
+	ExecAttachMessageSchema,
+	z.object({ type: z.literal("stdin_eof") }),
+	z.object({
+		type: z.literal("resize"),
+		cols: DimensionSchema,
+		rows: DimensionSchema
+	}),
+	z.object({
+		type: z.literal("signal"),
+		signal: z.string().regex(/^SIG[A-Z0-9]+$/)
+	})
+]);
+const ExecServerMessageSchema = z.discriminatedUnion("type", [
+	z.object({
+		type: z.literal("started"),
+		pid: z.int().positive(),
+		session: SessionNameSchema.optional(),
+		created: z.boolean().optional()
+	}),
+	z.object({
+		type: z.literal("exit"),
+		code: z.int().nullable(),
+		signal: z.string().nullable()
+	}),
+	z.object({
+		type: z.literal("detached"),
+		reason: z.enum([
+			"taken_over",
+			"slow",
+			"lost"
+		])
+	}),
+	z.object({
+		type: z.literal("error"),
+		message: z.string(),
+		code: z.string().optional(),
+		data: z.unknown().optional()
+	})
+]);
+function encodeExecFrame(channel, data) {
+	const frame = new Uint8Array(data.byteLength + 1);
+	frame[0] = channel;
+	frame.set(data, 1);
+	return frame;
+}
+function decodeExecFrame(frame) {
+	const [channel] = frame;
+	if (!isExecChannel(channel)) throw new Error(`exec frame has an unknown channel byte: ${String(channel)}`);
+	return {
+		channel,
+		data: frame.subarray(1)
+	};
+}
+function isExecChannel(value) {
+	return value === EXEC_CHANNELS.stdin || value === EXEC_CHANNELS.stdout || value === EXEC_CHANNELS.stderr;
+}
+//#endregion
+//#region src/exec/exec-error.ts
+var ExecError = class extends Error {
+	code;
+	data;
+	constructor(code, message, options = {}) {
+		const errorOptions = options.cause === void 0 ? {} : { cause: options.cause };
+		super(message, errorOptions);
+		this.name = "ExecError";
+		this.code = code;
+		this.data = options.data;
+	}
+};
+function toExecError(outcome) {
+	if (outcome.kind === "failed") return new ExecError(outcome.code ?? "EXEC_ERROR", outcome.message, { data: outcome.data });
+	if (outcome.kind === "unauthorized") return new ExecError("UNAUTHORIZED", outcome.ticketRefused === true ? "impd refused the exec ticket: it expired (30 s) or was used already" : "impd rejected the token");
+	if (outcome.kind === "unreachable") return new ExecError("UNREACHABLE", `cannot reach impd (${outcome.detail})`);
+	if (outcome.kind === "detached") return new ExecError("DETACHED", `detached from the session (${outcome.reason})`, { data: { reason: outcome.reason } });
+	if (outcome.kind === "closed") return outcome.closeCode === 1012 ? new ExecError("RESTARTING", "impd is restarting") : new ExecError("CONNECTION_CLOSED", `exec connection closed (${outcome.reason})`);
+	if (outcome.kind === "bad_message") return new ExecError("BAD_MESSAGE", `bad message from impd: ${outcome.detail}`);
+	return new ExecError("LOCAL_ERROR", "an output handler threw", { cause: outcome.error });
+}
+//#endregion
+//#region src/resolve-impd-url.ts
+function resolveImpdUrl(base, path) {
+	const url = new URL(base);
+	url.pathname = `${url.pathname.replace(/\/+$/, "")}${path}`;
+	return url;
+}
+//#endregion
+//#region src/exec/check-impd-access.ts
+const CHECK_TIMEOUT_MS = 5e3;
+async function checkImpdAccess(baseUrl, token, customFetch = fetch) {
+	try {
+		const response = await customFetch(new Request(resolveImpdUrl(baseUrl, "/rpc/system/info").href, {
+			method: "POST",
+			headers: token === null ? {} : { authorization: `Bearer ${token}` },
+			signal: AbortSignal.timeout(CHECK_TIMEOUT_MS)
+		}));
+		await response.body?.cancel();
+		return response.status === 401 ? "unauthorized" : "reachable";
+	} catch {
+		return "unreachable";
+	}
+}
+//#endregion
+//#region src/exec/open-exec-session.ts
+const OPEN_TIMEOUT_MS = 1e4;
+const HIGH_WATER_BYTES = 1048576;
+const DRAIN_POLL_MS = 50;
+var BadMessageError = class extends Error {
+	name = "BadMessageError";
+};
+function openExecSession(options) {
+	const url = resolveImpdUrl(options.baseUrl, EXEC_PATH);
+	url.protocol = url.protocol === "https:" ? "wss:" : "ws:";
+	if (options.ticket !== void 0) url.searchParams.set(EXEC_TICKET_PARAM, options.ticket);
+	const headers = options.token === null ? {} : { authorization: `Bearer ${options.token}` };
+	const ws = options.connect(url.href, headers);
+	const outcome = Promise.withResolvers();
+	const state = {
+		opened: false,
+		started: false,
+		finished: false
+	};
+	ws.binaryType = "arraybuffer";
+	const stopSocket = () => {
+		state.finished = true;
+		clearTimeout(openTimer);
+		ws.close();
+	};
+	const resolveOutcome = (result) => {
+		if (state.finished) return;
+		stopSocket();
+		outcome.resolve(result);
+	};
+	const openTimer = setTimeout(() => {
+		resolveOutcome({
+			kind: "unreachable",
+			detail: `no answer in ${String(OPEN_TIMEOUT_MS / 1e3)} s`
+		});
+	}, OPEN_TIMEOUT_MS);
+	const sendControl = (text) => {
+		if (!state.finished && ws.readyState === WebSocket.OPEN) ws.send(text);
+	};
+	const handleFrame = (data) => {
+		let frame;
+		try {
+			frame = decodeExecFrame(data);
+		} catch (error) {
+			throw new BadMessageError(error instanceof Error ? error.message : String(error));
+		}
+		if (frame.channel === EXEC_CHANNELS.stdin) throw new BadMessageError("impd sent data on the stdin channel");
+		const channel = frame.channel === EXEC_CHANNELS.stderr ? "stderr" : "stdout";
+		options.onOutput(channel, frame.data);
+	};
+	const handleControl = (text) => {
+		let json;
+		try {
+			json = JSON.parse(text);
+		} catch {
+			throw new BadMessageError(`not JSON: ${text.slice(0, 80)}`);
+		}
+		const parsed = ExecServerMessageSchema.safeParse(json);
+		if (!parsed.success) throw new BadMessageError(`unknown message: ${text.slice(0, 80)}`);
+		const message = parsed.data;
+		if (message.type === "started") {
+			if (state.started) return;
+			state.started = true;
+			options.onStarted({
+				pid: message.pid,
+				session: message.session ?? null,
+				created: message.created ?? false
+			});
+		} else if (message.type === "exit") resolveOutcome({
+			kind: "exit",
+			code: message.code,
+			signal: message.signal
+		});
+		else if (message.type === "detached") resolveOutcome({
+			kind: "detached",
+			reason: message.reason
+		});
+		else resolveOutcome({
+			kind: "failed",
+			code: message.code ?? null,
+			message: message.message,
+			...message.data !== void 0 && { data: message.data }
+		});
+	};
+	ws.addEventListener("open", () => {
+		state.opened = true;
+		clearTimeout(openTimer);
+		sendControl(JSON.stringify(buildOpenMessage(options.start)));
+	});
+	ws.addEventListener("message", (event) => {
+		if (state.finished) return;
+		try {
+			if (event.data instanceof ArrayBuffer) handleFrame(new Uint8Array(event.data));
+			else handleControl(String(event.data));
+		} catch (error) {
+			const failure = error instanceof BadMessageError ? {
+				kind: "bad_message",
+				detail: error.message
+			} : {
+				kind: "local_error",
+				error
+			};
+			resolveOutcome(failure);
+		}
+	});
+	const resolveRefusal = async (reason) => {
+		const access = await checkImpdAccess(options.baseUrl, options.token, options.fetch);
+		if (access === "unauthorized") resolveOutcome({ kind: "unauthorized" });
+		else if (access === "reachable" && options.ticket !== void 0) resolveOutcome({
+			kind: "unauthorized",
+			ticketRefused: true
+		});
+		else if (access === "unreachable") resolveOutcome({
+			kind: "unreachable",
+			detail: reason
+		});
+		else resolveOutcome({
+			kind: "closed",
+			reason
+		});
+	};
+	ws.addEventListener("close", (event) => {
+		if (state.finished) return;
+		const reason = event.reason === "" ? `code ${String(event.code)}` : event.reason;
+		if (state.opened) {
+			resolveOutcome({
+				kind: "closed",
+				reason,
+				closeCode: event.code
+			});
+			return;
+		}
+		resolveRefusal(reason);
+	});
+	const waitForDrain = async () => {
+		while (!state.finished && ws.bufferedAmount > HIGH_WATER_BYTES) await new Promise((resolve) => {
+			setTimeout(resolve, DRAIN_POLL_MS);
+		});
+	};
+	return {
+		outcome: outcome.promise,
+		isStarted: () => state.started,
+		sendStdin: (data) => {
+			if (!state.finished && ws.readyState === WebSocket.OPEN) ws.send(encodeExecFrame(EXEC_CHANNELS.stdin, data));
+			return ws.bufferedAmount <= HIGH_WATER_BYTES;
+		},
+		waitForDrain,
+		closeStdin: () => {
+			sendControl(JSON.stringify({ type: "stdin_eof" }));
+		},
+		resize: (cols, rows) => {
+			sendControl(JSON.stringify({
+				type: "resize",
+				cols,
+				rows
+			}));
+		},
+		sendSignal: (signal) => {
+			sendControl(JSON.stringify({
+				type: "signal",
+				signal
+			}));
+		},
+		stop: () => {
+			stopSocket();
+		}
+	};
+}
+function buildOpenMessage(start) {
+	if ("argv" in start) return {
+		type: "start",
+		...start,
+		argv: [...start.argv]
+	};
+	return {
+		type: "attach",
+		...start
+	};
+}
+//#endregion
+//#region src/exec/open-exec.ts
+const DEFAULT_MAX_UNREAD_BYTES = 8388608;
+const TTY_SIGNAL_KEYS = {
+	SIGINT: "",
+	SIGQUIT: ""
+};
+const CONSOLE_SHELL = [
+	"shell=",
+	"while IFS=: read -r user _ _ _ _ _ login; do",
+	"  if [ \"$user\" = root ]; then shell=$login; break; fi",
+	"done < /etc/passwd",
+	"[ -x \"$shell\" ] || shell=/bin/bash",
+	"[ -x \"$shell\" ] || shell=/bin/sh",
+	"exec \"$shell\" -l"
+].join("\n");
+function openExec(deps, name, argv, options = {}) {
+	const tty = options.tty ?? false;
+	return openHandle(deps, options, tty, {
+		name,
+		argv,
+		tty,
+		...options.env !== void 0 && { env: options.env },
+		...options.cwd !== void 0 && { cwd: options.cwd },
+		...options.cols !== void 0 && { cols: options.cols },
+		...options.rows !== void 0 && { rows: options.rows },
+		...options.session !== void 0 && { session: options.session }
+	});
+}
+function openAttach(deps, name, session, options = {}) {
+	return openHandle(deps, options, true, {
+		name,
+		session,
+		...options.cols !== void 0 && { cols: options.cols },
+		...options.rows !== void 0 && { rows: options.rows }
+	});
+}
+async function openHandle(deps, options, tty, start) {
+	const name = start.name;
+	const abort = options.signal;
+	const callOptions = abort === void 0 ? {} : { signal: abort };
+	abort?.throwIfAborted();
+	const issued = await deps.rpc.exec.ticket({ name }, callOptions);
+	abort?.throwIfAborted();
+	const maxUnreadBytes = options.maxUnreadBytes ?? DEFAULT_MAX_UNREAD_BYTES;
+	const started = Promise.withResolvers();
+	const ended = Promise.withResolvers();
+	const state = {
+		ended: false,
+		cancelled: 0
+	};
+	const stopWith = (code, message) => {
+		session.stop();
+		resolveHandle({ error: new ExecError(code, message) });
+	};
+	const outputHooks = {
+		maxUnreadBytes,
+		onOverflow: (channel) => {
+			stopWith("OUTPUT_OVERFLOW", `${channel} holds more than ${String(maxUnreadBytes)} unread bytes; read or cancel it`);
+		},
+		onCancel: () => {
+			state.cancelled += 1;
+			if (state.cancelled === 2) stopWith("CLOSED", "both output streams were cancelled");
+		}
+	};
+	const stdout = buildOutputStream("stdout", outputHooks);
+	const stderr = buildOutputStream("stderr", outputHooks);
+	const session = openExecSession({
+		baseUrl: deps.baseUrl,
+		token: deps.token,
+		ticket: issued.ticket,
+		start,
+		onStarted: (info) => {
+			started.resolve({ value: info });
+		},
+		onOutput: (channel, data) => {
+			(channel === "stderr" ? stderr : stdout).push(data);
+		},
+		connect: (url) => new WebSocket(url),
+		...deps.fetch !== void 0 && { fetch: deps.fetch }
+	});
+	const resolveHandle = (result) => {
+		if (state.ended) return;
+		state.ended = true;
+		stdout.end();
+		stderr.end();
+		abort?.removeEventListener("abort", stopSession);
+		if ("error" in result) started.resolve({ error: result.error });
+		ended.resolve(result);
+	};
+	const stopSession = () => {
+		stopWith("CLOSED", "the exec session was closed");
+	};
+	const waitForOutcome = async () => {
+		const outcome = await session.outcome;
+		const result = outcome.kind === "exit" ? { value: {
+			code: outcome.code,
+			signal: outcome.signal
+		} } : { error: toExecError(outcome) };
+		resolveHandle(result);
+	};
+	if (abort?.aborted === true) stopSession();
+	else abort?.addEventListener("abort", stopSession, { once: true });
+	waitForOutcome();
+	return buildHandle(session, {
+		started: started.promise,
+		ended: ended.promise,
+		isEnded: () => state.ended,
+		tty,
+		stopSession,
+		streams: [stdout.stream, stderr.stream]
+	});
+}
+function openConsole(deps, name, options = {}) {
+	return openExec(deps, name, [
+		"/bin/sh",
+		"-c",
+		CONSOLE_SHELL
+	], {
+		...options,
+		tty: true,
+		env: options.env ?? { TERM: "xterm-256color" }
+	});
+}
+async function runCommand(deps, name, argv, options = {}) {
+	const handle = await openExec(deps, name, argv, options);
+	const output = Promise.all([readAll(handle.stdout), readAll(handle.stderr)]);
+	if (options.stdin !== void 0) await handle.write(options.stdin);
+	await handle.closeStdin();
+	const [exit, [stdout, stderr]] = await Promise.all([handle.exit, output]);
+	return {
+		...exit,
+		stdout,
+		stderr
+	};
+}
+function buildHandle(session, parts) {
+	const encoder = new TextEncoder();
+	const waitForStart = async () => {
+		const result = await parts.started;
+		if ("error" in result) throw result.error;
+		return result.value;
+	};
+	const waitForExit = async () => {
+		const result = await parts.ended;
+		if ("error" in result) throw result.error;
+		return result.value;
+	};
+	const startedPromise = waitForStart();
+	const exitPromise = waitForExit();
+	waitIgnoringRejection(startedPromise);
+	waitIgnoringRejection(exitPromise);
+	const requireOpen = () => {
+		if (parts.isEnded()) throw new ExecError("CLOSED", "the exec session has ended");
+	};
+	const write = async (data) => {
+		requireOpen();
+		await startedPromise;
+		requireOpen();
+		const bytes = typeof data === "string" ? encoder.encode(data) : data;
+		if (!session.sendStdin(bytes)) await session.waitForDrain();
+	};
+	const sendKey = async (key) => {
+		try {
+			await write(key);
+		} catch {}
+	};
+	return {
+		started: startedPromise,
+		stdout: parts.streams[0],
+		stderr: parts.streams[1],
+		exit: exitPromise,
+		write,
+		closeStdin: async () => {
+			await startedPromise;
+			requireOpen();
+			session.closeStdin();
+		},
+		resize: (cols, rows) => {
+			session.resize(cols, rows);
+		},
+		sendSignal: (signal) => {
+			const key = parts.tty ? TTY_SIGNAL_KEYS[signal] : void 0;
+			if (key === void 0) session.sendSignal(signal);
+			else sendKey(key);
+		},
+		close: parts.stopSession
+	};
+}
+async function waitIgnoringRejection(promise) {
+	try {
+		await promise;
+	} catch {}
+}
+function buildOutputStream(channel, hooks) {
+	const state = {
+		controller: null,
+		open: true
+	};
+	return {
+		stream: new ReadableStream({
+			start: (controller) => {
+				state.controller = controller;
+			},
+			cancel: () => {
+				state.open = false;
+				hooks.onCancel();
+			}
+		}, {
+			highWaterMark: hooks.maxUnreadBytes,
+			size: (chunk) => chunk?.byteLength ?? 0
+		}),
+		push: (data) => {
+			if (!state.open || state.controller === null) return;
+			state.controller.enqueue(data);
+			if ((state.controller.desiredSize ?? 0) < 0) hooks.onOverflow(channel);
+		},
+		end: () => {
+			if (state.open) {
+				state.open = false;
+				state.controller?.close();
+			}
+		}
+	};
+}
+async function readAll(stream) {
+	const reader = stream.getReader();
+	const chunks = [];
+	for (;;) {
+		const result = await reader.read();
+		if (result.done) break;
+		chunks.push(result.value);
+	}
+	const all = new Uint8Array(chunks.reduce((sum, chunk) => sum + chunk.byteLength, 0));
+	let offset = 0;
+	for (const chunk of chunks) {
+		all.set(chunk, offset);
+		offset += chunk.byteLength;
+	}
+	return all;
+}
+//#endregion
+//#region src/require-awake.ts
+async function requireAwake(rpc, name, options = {}) {
+	const signal = options.signal;
+	const callOptions = signal === void 0 ? {} : { signal };
+	const retry = options.retryUnavailable ?? {
+		attempts: 0,
+		delayMs: 0
+	};
+	const input = {
+		name,
+		restartError: options.restartError === true
+	};
+	for (let attempt = 0;; attempt++) try {
+		return await rpc.imps.wake(input, callOptions);
+	} catch (error) {
+		if (!isUnavailable(error) || attempt >= retry.attempts) throw error;
+		await waitFor(retry.delayMs, signal);
+	}
+}
+function isUnavailable(error) {
+	if (error instanceof ORPCError$1) return error.code === "SERVICE_UNAVAILABLE";
+	return error instanceof TypeError;
+}
+function waitFor(ms, signal) {
+	signal?.throwIfAborted();
+	const done = Promise.withResolvers();
+	const onAbort = () => {
+		clearTimeout(timer);
+		done.reject(signal?.reason);
+	};
+	const timer = setTimeout(() => {
+		signal?.removeEventListener("abort", onAbort);
+		done.resolve();
+	}, ms);
+	signal?.addEventListener("abort", onAbort, { once: true });
+	return done.promise;
+}
+//#endregion
+//#region src/create-imp-client.ts
+function createImpClient(options) {
+	const token = options.token;
+	const customFetch = options.fetch;
+	const link = new RPCLink({
+		url: resolveImpdUrl(options.url, "/rpc").href,
+		headers: token === void 0 ? {} : { authorization: `Bearer ${token}` },
+		...customFetch !== void 0 && { fetch: (request) => customFetch(request) }
+	});
+	const rpc = createORPCClient(link);
+	const namespaces = {
+		imps: rpc.imps,
+		checkpoints: rpc.checkpoints,
+		images: rpc.images,
+		exec: rpc.exec,
+		sessions: rpc.sessions,
+		system: rpc.system
+	};
+	const execDeps = {
+		rpc,
+		baseUrl: options.url,
+		token: token ?? null,
+		...customFetch !== void 0 && { fetch: customFetch }
+	};
+	return {
+		...namespaces,
+		openExec: (name, argv, execOptions) => openExec(execDeps, name, argv, execOptions),
+		run: (name, argv, runOptions) => runCommand(execDeps, name, argv, runOptions),
+		openConsole: (name, consoleOptions) => openConsole(execDeps, name, consoleOptions),
+		openAttach: (name, session, attachOptions) => openAttach(execDeps, name, session, attachOptions),
+		requireAwake: (name, awakeOptions) => requireAwake(rpc, name, awakeOptions),
+		checkServer: () => checkServer(rpc)
+	};
+}
+//#endregion
+export { CLIENT_VERSION, CONSOLE_SHELL, ExecError, ORPCError, createImpClient, isDefinedError, openExecSession, safe };

package/package.json

@@ -0,0 +1,38 @@
+{
+  "name": "@zgeoff/imp-client",
+  "version": "0.0.0",
+  "description": "Typed client for impd, the imp host daemon: imps, checkpoints, images and exec",
+  "license": "MIT",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/zgeoff/imp.git",
+    "directory": "packages/client"
+  },
+  "type": "module",
+  "exports": {
+    ".": {
+      "types": "./dist/index.d.ts",
+      "default": "./dist/index.js"
+    }
+  },
+  "dependencies": {
+    "@orpc/client": "^1.14.15",
+    "@orpc/contract": "^1.14.15",
+    "zod": "^4.4.3"
+  },
+  "peerDependencies": {
+    "@opentelemetry/api": ">=1.9.0"
+  },
+  "peerDependenciesMeta": {
+    "@opentelemetry/api": {
+      "optional": true
+    }
+  },
+  "files": [
+    "dist"
+  ],
+  "sideEffects": false,
+  "publishConfig": {
+    "access": "public"
+  }
+}