annotate-anything 0.0.0-stage → 0.1.0

package/dist/node-SB91dcoI.js

@@ -0,0 +1,614 @@
+import { n as LOOPBACK_HOST, t as LOCAL_HOST } from "./local-W-uyrETY.js";
+import path from "node:path";
+import fs from "node:fs";
+import crypto from "node:crypto";
+// src/types.ts
+var LIFECYCLE = [
+	"status",
+	"sentAt",
+	"pickedUpAt",
+	"reply",
+	"resolvedAt"
+];
+// src/server/store.ts
+var KINDS = [
+	"pin",
+	"element",
+	"area"
+];
+var STATUSES = [
+	"open",
+	"sent",
+	"working",
+	"resolved"
+];
+var ID = /^[\w.-]{1,100}$/;
+var MAX_NOTES = 1e3;
+var LimitError = class extends Error {};
+var str = (v, max) => typeof v === "string" ? v.slice(0, max) : "";
+var line = (v, max) => str(v, max).replace(/[\u0000-\u001f\u007f-\u009f\u2028\u2029]+/g, " ").trim();
+var prose = (v, max) => str(v, max).replace(/[\u0000-\u0008\u000b-\u001f\u007f-\u009f\u2028\u2029]/g, "");
+var num = (v) => typeof v === "number" && Number.isFinite(v) ? Math.round(v * 10) / 10 : 0;
+var iso = (v) => typeof v === "string" && !Number.isNaN(Date.parse(v)) ? v.slice(0, 40) : void 0;
+function box(v) {
+	const b = v && typeof v === "object" ? v : {};
+	return {
+		x: num(b.x),
+		y: num(b.y),
+		width: num(b.width),
+		height: num(b.height)
+	};
+}
+function cleanNote(raw) {
+	if (!raw || typeof raw !== "object") return null;
+	const r = raw;
+	if (typeof r.id !== "string" || !ID.test(r.id)) return null;
+	const kind = KINDS.includes(r.kind) ? r.kind : null;
+	const comment = prose(r.comment, 2e4).trim();
+	if (!kind || !comment) return null;
+	let context = {};
+	if (r.context && typeof r.context === "object" && !Array.isArray(r.context) && JSON.stringify(r.context).length <= 4e3) context = r.context;
+	const scroll = r.scroll ?? {};
+	const viewport = r.viewport ?? {};
+	const note = {
+		id: r.id,
+		n: Number.isInteger(r.n) && r.n > 0 ? Math.min(r.n, 1e6) : 0,
+		kind,
+		route: line(r.route, 500) || "/",
+		comment,
+		createdAt: iso(r.createdAt) ?? (/* @__PURE__ */ new Date()).toISOString(),
+		updatedAt: iso(r.updatedAt) ?? (/* @__PURE__ */ new Date()).toISOString(),
+		status: STATUSES.includes(r.status) ? r.status : "open",
+		selector: line(r.selector, 1e3),
+		tag: line(r.tag, 40),
+		targetText: line(r.targetText, 400),
+		x: num(r.x),
+		y: num(r.y),
+		bounds: box(r.bounds),
+		scroll: {
+			x: num(scroll.x),
+			y: num(scroll.y)
+		},
+		viewport: {
+			width: num(viewport.width),
+			height: num(viewport.height)
+		},
+		inDialog: r.inDialog === true,
+		context
+	};
+	const origin = line(r.origin, 300);
+	if (origin) note.origin = origin;
+	const testId = line(r.testId, 200);
+	if (testId) note.testId = testId;
+	if (r.offset) note.offset = box(r.offset);
+	const sentAt = iso(r.sentAt);
+	if (sentAt) note.sentAt = sentAt;
+	const pickedUpAt = iso(r.pickedUpAt);
+	if (pickedUpAt) note.pickedUpAt = pickedUpAt;
+	const resolvedAt = iso(r.resolvedAt);
+	if (resolvedAt) note.resolvedAt = resolvedAt;
+	const reply = prose(r.reply, 2e4);
+	if (reply) note.reply = reply;
+	return note;
+}
+function sleep(ms) {
+	Atomics.wait(new Int32Array(new SharedArrayBuffer(4)), 0, 0, ms);
+}
+function alive(pid) {
+	if (typeof pid !== "number") return false;
+	try {
+		process.kill(pid, 0);
+		return true;
+	} catch (e) {
+		return e.code === "EPERM";
+	}
+}
+var FileStore = class {
+	dir;
+	feedback;
+	submissions;
+	watcher;
+	cursor;
+	lockPath;
+	constructor(dir) {
+		this.dir = dir;
+		this.feedback = path.join(dir, "feedback.json");
+		this.submissions = path.join(dir, "submissions.jsonl");
+		this.watcher = path.join(dir, "watcher.json");
+		this.cursor = path.join(dir, "watch.cursor");
+		this.lockPath = path.join(dir, ".lock");
+	}
+	ensure() {
+		fs.mkdirSync(this.dir, { recursive: true });
+		const ignore = path.join(this.dir, ".gitignore");
+		if (!fs.existsSync(ignore)) fs.writeFileSync(ignore, "*\n");
+	}
+	read() {
+		let raw;
+		try {
+			raw = fs.readFileSync(this.feedback, "utf8");
+		} catch (e) {
+			if (e.code === "ENOENT") return {
+				version: 1,
+				notes: [],
+				deleted: []
+			};
+			throw e;
+		}
+		try {
+			const d = JSON.parse(raw);
+			return {
+				version: 1,
+				notes: Array.isArray(d.notes) ? d.notes.map(cleanNote).filter(Boolean) : [],
+				deleted: Array.isArray(d.deleted) ? d.deleted.filter((x) => typeof x === "string") : []
+			};
+		} catch {
+			const kept = `${this.feedback}.corrupt-${Date.now()}`;
+			fs.renameSync(this.feedback, kept);
+			console.error(`annotate-anything: ${this.feedback} couldn't be read, so it was kept as ${kept}`);
+			return {
+				version: 1,
+				notes: [],
+				deleted: []
+			};
+		}
+	}
+	write(state) {
+		this.ensure();
+		const tmp = `${this.feedback}.${process.pid}.tmp`;
+		fs.writeFileSync(tmp, JSON.stringify(state, null, 1) + "\n");
+		fs.renameSync(tmp, this.feedback);
+	}
+	locked(fn) {
+		this.ensure();
+		const deadline = Date.now() + 5e3;
+		for (;;) try {
+			fs.closeSync(fs.openSync(this.lockPath, "wx"));
+			break;
+		} catch (e) {
+			if (e.code !== "EEXIST") throw e;
+			try {
+				if (Date.now() - fs.statSync(this.lockPath).mtimeMs > 1e4) fs.rmSync(this.lockPath, { force: true });
+			} catch {}
+			if (Date.now() > deadline) throw new Error(`Timed out waiting for ${this.lockPath}`);
+			sleep(15);
+		}
+		try {
+			return fn();
+		} finally {
+			fs.rmSync(this.lockPath, { force: true });
+		}
+	}
+	sync(incoming, deleted) {
+		return this.locked(() => {
+			const state = this.read();
+			const gone = /* @__PURE__ */ new Set([...state.deleted, ...deleted.filter((d) => typeof d === "string" && ID.test(d))]);
+			const byId = new Map(state.notes.map((n) => [n.id, n]));
+			const used = new Set(state.notes.map((n) => n.n));
+			for (const raw of incoming) {
+				const note = cleanNote(raw);
+				if (!note || gone.has(note.id)) continue;
+				const stored = byId.get(note.id);
+				if (!stored) {
+					if (!note.n || used.has(note.n)) note.n = Math.max(0, ...used) + 1;
+					used.add(note.n);
+					byId.set(note.id, note);
+					continue;
+				}
+				if (Date.parse(stored.updatedAt) > Date.parse(note.updatedAt)) continue;
+				note.n = stored.n;
+				const merged = { ...note };
+				for (const k of LIFECYCLE) if (stored[k] !== void 0) merged[k] = stored[k];
+				else delete merged[k];
+				byId.set(note.id, merged);
+			}
+			const next = {
+				version: 1,
+				notes: [...byId.values()].filter((n) => !gone.has(n.id)),
+				deleted: [...gone].slice(-5e3)
+			};
+			if (next.notes.length > 1e3) throw new LimitError(`At most ${MAX_NOTES} notes; clear the finished ones`);
+			this.write(next);
+			return next;
+		});
+	}
+	submit(ids, page) {
+		return this.locked(() => {
+			const state = this.read();
+			const want = new Set(ids.filter((x) => typeof x === "string"));
+			const fresh = state.notes.filter((n) => want.has(n.id) && n.status === "open");
+			if (!fresh.length) return {
+				sent: 0,
+				notes: []
+			};
+			const submittedAt = (/* @__PURE__ */ new Date()).toISOString();
+			for (const n of fresh) {
+				n.status = "sent";
+				n.sentAt = submittedAt;
+			}
+			const submission = {
+				id: crypto.randomUUID().replace(/-/g, ""),
+				submittedAt,
+				route: line(page.route, 500),
+				url: line(page.url, 2e3),
+				title: line(page.title, 300),
+				noteIds: fresh.map((n) => n.id),
+				count: fresh.length,
+				excerpts: fresh.map((n) => `#${n.n} ${n.comment.replace(/\s+/g, " ").slice(0, 140)}`)
+			};
+			this.write(state);
+			fs.appendFileSync(this.submissions, JSON.stringify(submission) + "\n");
+			return {
+				submission,
+				sent: fresh.length,
+				notes: fresh
+			};
+		});
+	}
+	resolveRefs(state, refs) {
+		const want = new Set(refs.map((ref) => ref.replace(/^#/, "")));
+		return state.notes.filter((n) => want.has(n.id) || want.has(String(n.n)));
+	}
+	setStatus(refs, status, reply) {
+		if (!STATUSES.includes(status)) throw new Error(`status must be one of ${STATUSES.join(", ")}`);
+		return this.locked(() => {
+			const state = this.read();
+			const notes = this.resolveRefs(state, refs);
+			const t = (/* @__PURE__ */ new Date()).toISOString();
+			for (const n of notes) {
+				n.status = status;
+				n.updatedAt = t;
+				if (status === "open") {
+					delete n.sentAt;
+					delete n.pickedUpAt;
+				}
+				if (status === "resolved") n.resolvedAt = t;
+				else delete n.resolvedAt;
+				if (reply !== void 0) {
+					const text = prose(reply, 2e4).trim();
+					if (text) n.reply = text;
+					else delete n.reply;
+				}
+			}
+			if (notes.length) this.write(state);
+			return notes;
+		});
+	}
+	pickUp(ids) {
+		this.locked(() => {
+			const state = this.read();
+			const want = new Set(ids);
+			const t = (/* @__PURE__ */ new Date()).toISOString();
+			let changed = false;
+			for (const n of state.notes) if (want.has(n.id) && n.status === "sent" && !n.pickedUpAt) {
+				n.pickedUpAt = t;
+				changed = true;
+			}
+			if (changed) this.write(state);
+		});
+	}
+	agent() {
+		try {
+			const name = JSON.parse(fs.readFileSync(path.join(this.dir, "agent.json"), "utf8")).name;
+			return typeof name === "string" && name.trim() ? name.trim().slice(0, 60) : void 0;
+		} catch {
+			return;
+		}
+	}
+	setAgent(name) {
+		this.ensure();
+		fs.writeFileSync(path.join(this.dir, "agent.json"), JSON.stringify({ name: name.trim().slice(0, 60) }) + "\n");
+	}
+	watching() {
+		try {
+			const info = JSON.parse(fs.readFileSync(this.watcher, "utf8"));
+			return Date.now() - Number(info.beat) < 6e3 && alive(info.pid);
+		} catch {
+			return false;
+		}
+	}
+};
+function dump(notes, file) {
+	if (!notes.length) return "No open UI notes.";
+	const lines = [
+		`${notes.length} UI note(s)`,
+		`file: ${file}`,
+		""
+	];
+	for (const n of [...notes].sort((a, b) => a.n - b.n)) {
+		lines.push(`#${n.n} [${n.status}] ${n.kind} on ${n.route}  ${n.selector || n.tag || "page"}`);
+		lines.push(`  id: ${n.id}`);
+		if (n.testId) lines.push(`  test id: ${n.testId}`);
+		if (n.targetText) lines.push(`  element text: ${JSON.stringify(n.targetText)}`);
+		const b = n.bounds;
+		lines.push(`  element box: x=${b.x} y=${b.y} w=${b.width} h=${b.height} (viewport ${n.viewport.width}x${n.viewport.height}, scrolled ${n.scroll.x},${n.scroll.y})`);
+		if (n.kind === "pin") lines.push(`  pin at: x=${n.x} y=${n.y}`);
+		if (n.kind === "area" && n.offset) lines.push(`  area in element: x=${n.offset.x} y=${n.offset.y} w=${n.offset.width} h=${n.offset.height}`);
+		if (n.inDialog) lines.push("  inside a dialog");
+		if (Object.keys(n.context).length) lines.push(`  context: ${JSON.stringify(n.context)}`);
+		lines.push(...n.comment.split("\n").map((l) => "  > " + l));
+		if (n.reply) lines.push(`  reply: ${n.reply.split("\n").join("\n    ")}`);
+		lines.push("");
+	}
+	return lines.join("\n").trimEnd();
+}
+// src/server/core.ts
+var quote = (s) => `'${s.replace(/'/g, `'\\''`)}'`;
+function handoff(batch, command = "npx annotate-anything") {
+	const dir = quote(path.dirname(batch.file));
+	const as = batch.agent ? ` --agent ${quote(batch.agent)}` : "";
+	const lines = [...batch.notes].sort((a, b) => a.n - b.n).map((n) => `- #${n.n} ${n.kind} on ${n.route} (${n.selector || n.tag}${n.targetText ? ` "${n.targetText.slice(0, 80)}"` : ""}): ${n.comment.replace(/\s+/g, " ")}`);
+	const head = `UI notes from annotate-anything on ${batch.submission.url || batch.submission.route}:`;
+	const tail = `\nFull details (selectors, element text, boxes, viewport) are in ${batch.file}. For each note, run \`${command} status <n> working --dir ${dir}${as}\`, make the change, verify it, then \`${command} status <n> resolved --reply "<what changed>" --dir ${dir}${as}\`. Leave a note open and reply why if you change nothing.`;
+	let body = lines.join("\n");
+	if ((head + body + tail).length > 5800) body = body.slice(0, 5800 - head.length - tail.length - 20) + "\n- …";
+	return `${head}\n${body}${tail}`;
+}
+var SYNC_LIMIT = 524288;
+var SMALL_LIMIT = 65536;
+var HttpError = class extends Error {
+	status;
+	constructor(status, message) {
+		super(message);
+		this.status = status;
+	}
+};
+function isLocalOrigin(origin) {
+	try {
+		const u = new URL(origin);
+		return (u.protocol === "http:" || u.protocol === "https:") && LOCAL_HOST.test(u.hostname);
+	} catch {
+		return false;
+	}
+}
+function isLoopbackOrigin(origin) {
+	try {
+		const u = new URL(origin);
+		return (u.protocol === "http:" || u.protocol === "https:") && LOOPBACK_HOST.test(u.hostname);
+	} catch {
+		return false;
+	}
+}
+var isLoopbackAddress = (a) => /^(127\.|::1$|::ffff:127\.|localhost$)/.test(a.trim());
+function fromElsewhere(req) {
+	if (req.remote && !isLoopbackAddress(req.remote)) return true;
+	return (req.header("x-forwarded-for") ?? "").split(",").some((a) => a.trim() && !isLoopbackAddress(a));
+}
+function isKnownHost(host, allowed) {
+	if (allowed === true) return true;
+	try {
+		const name = new URL(`http://${host}`).hostname;
+		return LOCAL_HOST.test(name) || !!allowed?.some((a) => a.startsWith(".") ? name === a.slice(1) || name.endsWith(a) : name === a);
+	} catch {
+		return false;
+	}
+}
+function inProduction(options) {
+	return process.env.NODE_ENV === "production" && !options.enabled;
+}
+function createCore(options = {}) {
+	const root = process.cwd();
+	const store = new FileStore(path.resolve(
+		/*turbopackIgnore: true*/
+		root,
+		options.dir ?? ".annotations"
+	));
+	if (!inProduction(options)) try {
+		store.ensure();
+	} catch {}
+	const base = (options.base ?? "/__annotate").replace(/\/$/, "");
+	const state = () => ({
+		...store.read(),
+		watching: store.watching(),
+		agent: store.agent()
+	});
+	async function json(req, limit) {
+		if (Number(req.header("content-length") ?? 0) > limit) throw new HttpError(413, "Request too large");
+		const raw = await req.body(limit);
+		try {
+			const v = JSON.parse(raw || "{}");
+			if (!v || typeof v !== "object" || Array.isArray(v)) throw new Error();
+			return v;
+		} catch {
+			throw new HttpError(400, "Body must be a JSON object");
+		}
+	}
+	async function route(req, route) {
+		if (route === "/client.js" && req.method === "GET") {
+			const bundle = options.clientScript?.() ?? null;
+			if (!bundle) throw new HttpError(404, "The browser bundle is missing; build annotate-anything first");
+			const host = req.header("host") ?? "localhost";
+			const proto = req.header("x-forwarded-proto") ?? "http";
+			return { script: `window.__ANNOTATE_ANYTHING__=Object.assign(${JSON.stringify({
+				endpoint: `${proto}://${host}${base}`,
+				enabled: true
+			})},window.__ANNOTATE_ANYTHING__||{});\n${bundle}` };
+		}
+		if (route === "/feedback" && req.method === "GET") return { data: state() };
+		if (route === "/targets" && req.method === "GET") return { data: { targets: await options.targets?.() ?? [] } };
+		if (req.method !== "POST") throw new HttpError(405, "Method not allowed");
+		if (!String(req.header("content-type") ?? "").includes("application/json")) throw new HttpError(415, "Use Content-Type: application/json");
+		if (route === "/feedback") {
+			const b = await json(req, SYNC_LIMIT);
+			const notes = Array.isArray(b.notes) ? b.notes : [];
+			const deleted = Array.isArray(b.deleted) ? b.deleted : [];
+			if (notes.length > 1e3) throw new HttpError(413, `At most ${MAX_NOTES} notes`);
+			store.sync(notes, deleted);
+			return { data: state() };
+		}
+		if (route === "/feedback/submit") {
+			const b = await json(req, SMALL_LIMIT);
+			const ids = Array.isArray(b.noteIds) ? b.noteIds : [];
+			const target = typeof b.target === "string" && b.target ? b.target.slice(0, 200) : void 0;
+			const agent = target && typeof b.agent === "string" ? b.agent.slice(0, 120) : void 0;
+			const result = store.submit(ids, b);
+			let delivery;
+			let prompt;
+			if (result.submission) {
+				const batch = {
+					notes: result.notes,
+					submission: result.submission,
+					file: store.feedback,
+					root,
+					target,
+					agent
+				};
+				prompt = handoff(batch, options.command);
+				if (options.onSubmit) try {
+					delivery = await options.onSubmit({
+						...batch,
+						prompt
+					}) ?? void 0;
+				} catch (e) {
+					delivery = {
+						to: "The onSubmit hook",
+						ok: false,
+						detail: e instanceof Error ? e.message : String(e)
+					};
+				}
+			}
+			if (delivery?.ok) {
+				store.pickUp(result.submission.noteIds);
+				if (agent) store.setAgent(agent);
+			}
+			const forward = target && !options.onSubmit ? { handoff: prompt } : {};
+			return { data: {
+				submission: result.submission,
+				sent: result.sent,
+				watching: store.watching(),
+				agent: store.agent(),
+				delivery,
+				...forward
+			} };
+		}
+		if (route === "/feedback/status") {
+			const b = await json(req, SMALL_LIMIT);
+			const refs = (Array.isArray(b.ids) ? b.ids : [b.id ?? b.n]).filter((x) => x !== void 0 && x !== null).map(String);
+			if (!refs.length) throw new HttpError(400, "Pass ids");
+			if (b.reply !== void 0 && typeof b.reply !== "string") throw new HttpError(400, "reply must be a string");
+			if (![
+				"open",
+				"sent",
+				"working",
+				"resolved"
+			].includes(String(b.status))) throw new HttpError(400, "status must be open, sent, working or resolved");
+			const notes = store.setStatus(refs, b.status, b.reply);
+			if (!notes.length) throw new HttpError(404, "No matching notes");
+			return { data: { notes } };
+		}
+		throw new HttpError(404, "Not found");
+	}
+	async function handle(req) {
+		const pathname = req.url.split("?")[0];
+		if (pathname !== base && !pathname.startsWith(base + "/")) return null;
+		if (!options.allowRemote && fromElsewhere(req)) return {
+			status: 403,
+			headers: {
+				"Cache-Control": "no-store",
+				"Content-Type": "application/json"
+			},
+			body: JSON.stringify({ error: "annotate-anything only answers this machine; set allowRemote: true if you trust this network" })
+		};
+		const host = req.header("host");
+		if (host && !isKnownHost(host, options.allowedHosts)) return {
+			status: 403,
+			headers: {
+				"Cache-Control": "no-store",
+				"Content-Type": "application/json"
+			},
+			body: JSON.stringify({ error: `annotate-anything doesn't answer to ${host}; add it to allowedHosts if you trust it` })
+		};
+		const origin = req.header("origin");
+		let sameOrigin = true;
+		if (origin) try {
+			sameOrigin = new URL(origin).host === req.header("host");
+		} catch {
+			sameOrigin = false;
+		}
+		const cross = !!origin && !sameOrigin && !!options.allowOrigin?.(origin);
+		const headers = { "Cache-Control": "no-store" };
+		if (cross) Object.assign(headers, {
+			"Access-Control-Allow-Origin": origin,
+			Vary: "Origin"
+		});
+		const reply = (status, data) => ({
+			status,
+			headers: {
+				...headers,
+				"Content-Type": "application/json"
+			},
+			body: JSON.stringify(data)
+		});
+		if (req.method === "OPTIONS") {
+			if (!cross) return reply(403, { error: "Cross-origin requests are not allowed" });
+			const h = {
+				...headers,
+				"Access-Control-Allow-Methods": "GET, POST",
+				"Access-Control-Allow-Headers": "Content-Type",
+				"Access-Control-Max-Age": "600"
+			};
+			if (req.header("access-control-request-private-network")) h["Access-Control-Allow-Private-Network"] = "true";
+			return {
+				status: 204,
+				headers: h,
+				body: ""
+			};
+		}
+		const site = req.header("sec-fetch-site");
+		const script = pathname === base + "/client.js";
+		if (!script && origin && !sameOrigin && !cross) return reply(403, { error: "Cross-origin requests are not allowed" });
+		if (!script && site && site !== "same-origin" && site !== "none" && !cross) return reply(403, { error: "Cross-site requests are not allowed" });
+		try {
+			const out = await route(req, pathname.slice(base.length));
+			if (out.script !== void 0) return {
+				status: 200,
+				headers: {
+					...headers,
+					"Content-Type": "text/javascript; charset=utf-8"
+				},
+				body: out.script
+			};
+			return reply(out.status ?? 200, out.data);
+		} catch (e) {
+			return reply(e instanceof HttpError ? e.status : e instanceof LimitError ? 413 : e instanceof Error && /status must be/.test(e.message) ? 400 : 500, { error: e instanceof Error ? e.message : String(e) });
+		}
+	}
+	return {
+		base,
+		store,
+		handle
+	};
+}
+// src/server/node.ts
+function readBody(req, limit) {
+	const parsed = req.body;
+	if (parsed !== void 0) {
+		const text = typeof parsed === "string" ? parsed : Buffer.isBuffer(parsed) ? parsed.toString("utf8") : JSON.stringify(parsed);
+		return Buffer.byteLength(text) > limit ? Promise.reject(new HttpError(413, "Request too large")) : Promise.resolve(text);
+	}
+	if (req.readableEnded) return Promise.reject(new HttpError(400, "Something already read the request body; add annotate-anything before your body parser"));
+	return new Promise((resolve, reject) => {
+		const chunks = [];
+		let size = 0;
+		req.on("data", (c) => {
+			size += c.length;
+			if (size > limit) reject(new HttpError(413, "Request too large"));
+			else chunks.push(c);
+		});
+		req.on("end", () => resolve(Buffer.concat(chunks).toString("utf8")));
+		req.on("error", reject);
+	});
+}
+function nodeRequest(req) {
+	return {
+		remote: req.socket?.remoteAddress,
+		method: req.method ?? "GET",
+		url: req.url ?? "/",
+		header: (name) => {
+			const v = req.headers[name.toLowerCase()];
+			return Array.isArray(v) ? v[0] : v;
+		},
+		body: (limit) => readBody(req, limit)
+	};
+}
+export { isKnownHost as a, FileStore as c, inProduction as i, dump as l, HttpError as n, isLocalOrigin as o, createCore as r, isLoopbackOrigin as s, nodeRequest as t };

package/dist/react.js

@@ -0,0 +1,13 @@
+"use client";
+import { t as annotate } from "./src-DTByJ6QG.js";
+import { useEffect } from "react";
+// src/react.ts
+function Annotate(props) {
+	useEffect(() => {
+		if (process.env.NODE_ENV === "production" && !props.enabled) return;
+		const tool = annotate(props);
+		return () => tool.destroy();
+	}, []);
+	return null;
+}
+export { Annotate, Annotate as default };