@marver-design/marver 0.10.1 → 0.11.0

package/dist/{shot-BRgPaFCs.mjs → shot-Cyv3GN79.mjs}

@@ -1,8 +1,8 @@
 import { i as ROUTE } from "./cli.mjs";
 import { existsSync, mkdirSync, mkdtempSync, readFileSync, rmSync, writeFileSync } from "node:fs";
 import { join } from "node:path";
-import { spawn } from "node:child_process";
 import { tmpdir } from "node:os";
+import { spawn } from "node:child_process";
 //#region src/server/shot.ts
 /**
 * Frame screenshots without a dependency - the system's own Chrome, driven over CDP
@@ -34,6 +34,29 @@ function findChrome() {
 	return CHROMES.find((p) => existsSync(p)) ?? null;
 }
 const slug = (frameId) => frameId.replace(/\//g, "--");
+const clamp = (n, lo, hi) => Math.min(hi, Math.max(lo, n));
+function planShot(frame, viewports) {
+	const cw = typeof frame.contentWidth === "number" && Number.isFinite(frame.contentWidth) && frame.contentWidth > 0 ? frame.contentWidth : void 0;
+	const vpObj = frame.viewport ? viewports[frame.viewport] : void 0;
+	const fallback = viewports.mobile ?? {
+		width: 390,
+		height: 844
+	};
+	if (cw) {
+		const width = clamp(vpObj?.width ?? cw, 320, 1600);
+		return {
+			width,
+			initialHeight: Math.round(width * .75),
+			fullHeight: true
+		};
+	}
+	const vp = vpObj ?? fallback;
+	return {
+		width: vp.width,
+		initialHeight: vp.height,
+		fullHeight: false
+	};
+}
 /** Resolve a frame from the manifest and screenshot it - the shared core behind BOTH
 *  transports (the HTTP /api/shot endpoint and the file-drop inbox), so they validate and
 *  name output identically. `origin` is the dev server's own base URL. */
@@ -52,24 +75,27 @@ async function shootFrame(opts) {
 		ok: false,
 		error: `unknown frame "${frameId}" - ids are in design/manifest.json`
 	};
-	const vp = viewports[frame.viewport ?? ""] ?? viewports.mobile ?? {
-		width: 390,
-		height: 844
-	};
+	const plan = planShot(frame, viewports);
 	const shotsDir = join(root, "design", ".local", "shots");
 	mkdirSync(shotsDir, { recursive: true });
 	const rel = `design/.local/shots/${slug(frameId)}--${theme}.png`;
 	const result = await capture({
 		url: frame.kind === "html" ? `${origin}/${frame.file}?theme=${encodeURIComponent(theme)}` : `${origin}${ROUTE}/frame/?id=${encodeURIComponent(frameId)}&theme=${encodeURIComponent(theme)}`,
-		width: vp.width,
-		height: vp.height,
-		out: join(root, rel)
+		width: plan.width,
+		height: plan.initialHeight,
+		out: join(root, rel),
+		fullHeight: plan.fullHeight
 	});
 	return result.ok ? {
 		ok: true,
 		path: rel,
-		width: vp.width,
-		height: vp.height
+		width: result.width,
+		height: result.height,
+		scale: result.scale,
+		...result.truncated ? {
+			truncated: true,
+			note: result.note
+		} : {}
 	} : result;
 }
 /** One capture at a time: shots are seconds apart at most, and a Chrome per concurrent
@@ -80,7 +106,7 @@ function capture(req) {
 	chain = run;
 	return run;
 }
-async function captureNow({ url, width, height, out, timeoutMs = 3e4 }) {
+async function captureNow({ url, width, height, out, fullHeight = false, timeoutMs = 3e4 }) {
 	const bin = findChrome();
 	if (!bin) return {
 		ok: false,
@@ -172,6 +198,7 @@ async function captureNow({ url, width, height, out, timeoutMs = 3e4 }) {
 				rej(e);
 			}
 		});
+		const sendD = (method, params, ms = 1500) => Promise.race([send(method, params, sessionId), new Promise((_, rej) => setTimeout(() => rej(/* @__PURE__ */ new Error(`${method} timed out`)), ms))]);
 		watchdog = setTimeout(() => {
 			try {
 				chrome.kill("SIGKILL");
@@ -226,9 +253,109 @@ async function captureNow({ url, width, height, out, timeoutMs = 3e4 }) {
 			ok: false,
 			error: `the frame rendered an error - ${frameError}`
 		};
-		const shot = await send("Page.captureScreenshot", { format: "png" }, sessionId);
+		let capW = width, capH = height, scale = 2, truncated = false, note = "";
+		if (fullHeight) {
+			const wait = (ms) => new Promise((r) => setTimeout(r, ms));
+			const measureH = async () => {
+				const v = (await sendD("Runtime.evaluate", {
+					expression: `Math.ceil((document.querySelector('.mv-doc')||document.getElementById('root')||document.body).getBoundingClientRect().height)`,
+					returnByValue: true
+				}).catch(() => null))?.result?.value;
+				return typeof v === "number" && Number.isFinite(v) ? v : 0;
+			};
+			const lodIdle = async () => {
+				const v = (await sendD("Runtime.evaluate", {
+					expression: `(typeof window.__mvLodBusy==='function')?window.__mvLodBusy():0`,
+					returnByValue: true
+				}).catch(() => null))?.result?.value;
+				return typeof v === "number" ? v === 0 : true;
+			};
+			let measured = 0;
+			const growFit = async (dsf, capCss, deadline) => {
+				let h = Math.max(height, 2e3), prev = -1;
+				for (let i = 0; i < 8 && Date.now() < deadline; i++) {
+					await sendD("Emulation.setDeviceMetricsOverride", {
+						width,
+						height: Math.min(h, capCss),
+						deviceScaleFactor: dsf,
+						mobile: false
+					}).catch(() => {});
+					if (Date.now() >= deadline) break;
+					await sendD("Runtime.evaluate", {
+						expression: "document.fonts.ready.then(()=>true)",
+						awaitPromise: true,
+						returnByValue: true
+					}).catch(() => null);
+					if (Date.now() >= deadline) break;
+					for (let j = 0; j < 10 && Date.now() < deadline && !await lodIdle(); j++) await wait(100);
+					if (Date.now() >= deadline) break;
+					await wait(150);
+					if (Date.now() >= deadline) break;
+					const m = await measureH();
+					if (m > 0) measured = m;
+					const capped = Math.min(h, capCss);
+					if (capped >= capCss) break;
+					if (m > 0 && m <= capped && m === prev) break;
+					prev = m;
+					h = Math.max(m, capped);
+				}
+			};
+			const CAP2 = 8192, CAP1 = 16384;
+			const settleDeadline = Date.now() + 6e3;
+			await growFit(2, CAP2, settleDeadline);
+			if (measured > CAP2) {
+				scale = 1;
+				await growFit(1, CAP1, settleDeadline);
+			}
+			const cap = scale === 2 ? CAP2 : CAP1;
+			capW = width;
+			if (measured > cap) {
+				capH = cap;
+				truncated = true;
+				note = `frame is ${measured}px tall; captured the top ${cap}px - split it or reduce its height`;
+			} else capH = clamp(measured || height, 80, cap);
+			await sendD("Emulation.setDeviceMetricsOverride", {
+				width: capW,
+				height: capH,
+				deviceScaleFactor: scale,
+				mobile: false
+			}, 5e3);
+			if (Date.now() < settleDeadline) {
+				await sendD("Runtime.evaluate", {
+					expression: `window.postMessage({type:'sh:camera',moving:false,scale:1}, location.origin)`,
+					returnByValue: true
+				}).catch(() => null);
+				await wait(300);
+				for (let j = 0; j < 20 && Date.now() < settleDeadline && !await lodIdle(); j++) await wait(100);
+				await sendD("Runtime.evaluate", {
+					expression: "document.fonts.ready.then(()=>true)",
+					awaitPromise: true,
+					returnByValue: true
+				}).catch(() => null);
+			}
+		}
+		const shot = await sendD("Page.captureScreenshot", {
+			format: "png",
+			captureBeyondViewport: true,
+			clip: {
+				x: 0,
+				y: 0,
+				width: capW,
+				height: capH,
+				scale: 1
+			}
+		}, 15e3);
 		writeFileSync(out, Buffer.from(String(shot.data), "base64"));
-		return { ok: true };
+		return {
+			ok: true,
+			width: capW,
+			height: capH,
+			scale,
+			...truncated ? {
+				truncated: true,
+				note
+			} : {}
+		};
 	} catch (err) {
 		return {
 			ok: false,

package/dist/sync-DELGomPk.mjs

@@ -0,0 +1,397 @@
+import { t as __exportAll } from "./rolldown-runtime-D7D4PA-g.mjs";
+import { i as readLog, r as listBoards, t as appendEvents } from "./comments-DZyobpxG.mjs";
+import { t as CLI_TOKEN_CHARS } from "./auth-B5yuwnOq.mjs";
+import { chmodSync, closeSync, existsSync, mkdirSync, openSync, readFileSync, realpathSync, renameSync, unlinkSync, writeSync } from "node:fs";
+import { join } from "node:path";
+import { createHash, randomBytes } from "node:crypto";
+import { homedir } from "node:os";
+//#region src/shared/events.ts
+/** Events the other side lacks, by id - the sync payload in either direction. */
+function diffEvents(mine, theirIds) {
+	const have = new Set(theirIds);
+	return mine.filter((e) => !have.has(e.id));
+}
+/** Replay a board's events into current thread state. Deterministic: replay order is
+*  (ts, id) so two stores holding the same event SET always derive the same state.
+*  TWO passes - creates first, then everything else - so a reply whose author's clock
+*  ran ahead of the creator's still lands instead of being dropped forever. */
+function replay(events) {
+	const ordered = [...events].sort((a, b) => a.ts - b.ts || (a.id < b.id ? -1 : 1));
+	const threads = /* @__PURE__ */ new Map();
+	for (const ev of ordered) {
+		if (ev.type !== "create") continue;
+		if (!ev.commentId || threads.has(ev.commentId)) continue;
+		threads.set(ev.commentId, {
+			id: ev.commentId,
+			board: ev.board,
+			nodeKey: ev.nodeKey,
+			frame: ev.frame,
+			anchor: ev.anchor,
+			author: ev.author,
+			body: ev.body,
+			ts: ev.ts,
+			resolved: false,
+			agent: ev.agent,
+			agentMeta: ev.agentMeta,
+			replies: [],
+			reactions: {}
+		});
+	}
+	for (const ev of ordered) switch (ev.type) {
+		case "reply": {
+			const t = ev.parentId ? threads.get(ev.parentId) : void 0;
+			if (!t || !ev.commentId || t.replies.some((r) => r.id === ev.commentId)) break;
+			t.replies.push({
+				id: ev.commentId,
+				author: ev.author,
+				body: ev.body,
+				ts: ev.ts,
+				agent: ev.agent,
+				agentMeta: ev.agentMeta
+			});
+			break;
+		}
+		case "edit": {
+			if (!ev.commentId || ev.body === void 0) break;
+			const t = threads.get(ev.commentId);
+			if (t) {
+				t.body = ev.body;
+				break;
+			}
+			for (const th of threads.values()) {
+				const r = th.replies.find((r) => r.id === ev.commentId);
+				if (r) {
+					r.body = ev.body;
+					break;
+				}
+			}
+			break;
+		}
+		case "resolve": {
+			const t = ev.commentId ? threads.get(ev.commentId) : void 0;
+			if (t) {
+				t.resolved = true;
+				if (ev.addressedIn) t.addressedIn = ev.addressedIn;
+			}
+			break;
+		}
+		case "reopen": {
+			const t = ev.commentId ? threads.get(ev.commentId) : void 0;
+			if (t) {
+				t.resolved = false;
+				t.addressedIn = void 0;
+			}
+			break;
+		}
+		case "reanchor": {
+			const t = ev.commentId ? threads.get(ev.commentId) : void 0;
+			if (t && ev.anchor != null) t.anchor = ev.anchor;
+			break;
+		}
+		case "react": {
+			const t = ev.commentId ? threads.get(ev.commentId) : void 0;
+			const who = ev.author?.email;
+			if (!t || !who || !ev.emoji) break;
+			const users = t.reactions[ev.emoji] ??= [];
+			const at = users.indexOf(who);
+			if (at === -1) users.push(who);
+			else {
+				users.splice(at, 1);
+				if (!users.length) delete t.reactions[ev.emoji];
+			}
+			break;
+		}
+	}
+	return [...threads.values()];
+}
+//#endregion
+//#region src/server/sync.ts
+/**
+* Dev ↔ published comment sync - one merge rule, run from the dev side.
+*
+* The published serve is the canonical home; the repo's design/comments/ is the
+* mirror the agent reads. Each exchange is: pull remote events → union into local
+* files; push the local events the remote lacks (chunked - the server unions too).
+* Idempotent and retry-safe by construction, so a dropped exchange costs nothing.
+*
+* Credentials: ~/.marver/canvases/<hash-of-project-path>.json {url, token},
+* written by `comments connect`. Deliberately OUTSIDE the repository - a dev
+* server serves the repository, and no amount of path guarding makes a secret
+* inside a published tree safe. The token is always a server SESSION - expiring,
+* and ended by rotating MARVER_CLI_TOKEN - never the operator's secret itself,
+* which is traded for one and then forgotten.
+*/
+var sync_exports = /* @__PURE__ */ __exportAll({
+	connect: () => connect,
+	connectClaim: () => connectClaim,
+	connectToken: () => connectToken,
+	loadCollab: () => loadCollab,
+	saveCollab: () => saveCollab,
+	syncOnce: () => syncOnce
+});
+/**
+* The credential does not live in the repository.
+*
+* It used to, at `design/.local/collab.json`, and `marver dev` puts the
+* repository on the web so frames can import from it. Two rounds of guards -
+* a deny list, then a realpath check - each closed a way to read it and each was
+* followed by another: a symlink, then `public/`, then Vite's derived
+* `index`/`.html` candidates. Enumerating every path a bundler might resolve is
+* not a thing anyone can finish.
+*
+* So the file moved out of reach instead. Under the user's home, keyed by the
+* absolute path of the project it belongs to, one file per canvas per machine.
+* Nothing serves that directory, so there is no path to guard.
+*
+* The old location is still read once, moved, and removed - a credential left
+* behind in a repo is exactly the thing being fixed.
+*/
+const legacyCollabFile = (root) => join(root, "design", ".local", "collab.json");
+const collabDir = () => join(homedir(), ".marver", "canvases");
+const collabFile = (root) => {
+	let canonical = root;
+	try {
+		canonical = realpathSync(root);
+	} catch {}
+	const key = createHash("sha256").update(canonical).digest("hex").slice(0, 32);
+	return join(collabDir(), `${key}.json`);
+};
+/** Move a credential written by an older marver out of the repository. Best
+*  effort in one direction only: if anything here fails the old file is left
+*  alone and `loadCollab` still reads it, so nobody is locked out by a tidy-up. */
+function migrateLegacy(root) {
+	const from = legacyCollabFile(root);
+	if (!existsSync(from)) return;
+	if (readCollab(collabFile(root))) {
+		try {
+			unlinkSync(from);
+		} catch {}
+		return;
+	}
+	const collab = readCollab(from);
+	if (!collab) return;
+	try {
+		saveCollab(root, collab);
+	} catch {}
+}
+/** A credential file, or null if it is missing, unreadable or not one. */
+function readCollab(file) {
+	try {
+		const c = JSON.parse(readFileSync(file, "utf8"));
+		return typeof c?.url === "string" && typeof c?.token === "string" ? c : null;
+	} catch {
+		return null;
+	}
+}
+function loadCollab(root) {
+	migrateLegacy(root);
+	return readCollab(collabFile(root)) ?? readCollab(legacyCollabFile(root));
+}
+function saveCollab(root, collab) {
+	const dir = collabDir();
+	const file = collabFile(root);
+	mkdirSync(dir, {
+		recursive: true,
+		mode: 448
+	});
+	try {
+		chmodSync(dir, 448);
+	} catch {}
+	/**
+	* Written through a temp file created O_EXCL at 0600, then renamed.
+	*
+	* Writing in place and fixing the mode afterwards leaves a window - and, after
+	* a crash, no window at all but a token sitting under the previous file's
+	* permissions. Creating the temp file with the mode means the credential is
+	* never on disk readable, not even briefly, and rename is atomic so a reader
+	* sees the old file or the new one.
+	*/
+	const tmp = `${file}.${randomBytes(6).toString("hex")}.tmp`;
+	const fd = openSync(tmp, "wx", 384);
+	try {
+		writeSync(fd, JSON.stringify(collab, null, 2) + "\n");
+	} finally {
+		closeSync(fd);
+	}
+	try {
+		renameSync(tmp, file);
+	} catch (err) {
+		try {
+			unlinkSync(tmp);
+		} catch {}
+		throw err;
+	}
+	try {
+		unlinkSync(legacyCollabFile(root));
+	} catch {}
+}
+/** One full exchange. Returns per-board counts, or throws on auth/network failure. */
+async function syncOnce(root, collab) {
+	const dir = join(root, "design", "comments");
+	const auth = { authorization: `Bearer ${collab.token}` };
+	const base = collab.url.replace(/\/+$/, "");
+	const bres = await fetch(`${base}/__mv/api/boards`, { headers: auth });
+	if (bres.status === 401) throw new Error("the connect token was rejected - run `comments connect` again");
+	if (!bres.ok) throw new Error(`published canvas answered ${bres.status} - is it up?`);
+	const { rights } = await bres.json();
+	const boards = [.../* @__PURE__ */ new Set([...Object.keys(rights), ...listBoards(dir)])];
+	const out = {};
+	const failures = [];
+	for (const board of boards) {
+		if (!(board in rights)) continue;
+		const res = await fetch(`${base}/__mv/api/comments/${board}`, { headers: auth });
+		if (!res.ok) {
+			failures.push(`${board}: pull ${res.status}`);
+			continue;
+		}
+		const { events: remote } = await res.json();
+		const pulled = appendEvents(dir, board, remote).length;
+		let pushed = 0;
+		if (rights[board] === "comment") {
+			const missing = diffEvents(readLog(dir, board), remote.map((e) => e.id)).filter((e) => !e.agent);
+			for (let i = 0; i < missing.length; i += 100) {
+				const r = await fetch(`${base}/__mv/api/comments/${board}`, {
+					method: "POST",
+					headers: {
+						...auth,
+						"content-type": "application/json"
+					},
+					body: JSON.stringify({ events: missing.slice(i, i + 100) })
+				});
+				if (r.ok) pushed += (await r.json()).accepted ?? 0;
+				else failures.push(`${board}: push ${r.status} ${(await r.json().catch(() => null))?.error ?? ""}`.trim());
+			}
+		}
+		out[board] = {
+			pulled,
+			pushed
+		};
+	}
+	if (failures.length) throw new Error(`sync incomplete - ${failures.join(" · ")}`);
+	return out;
+}
+/** The account endpoints live BEHIND the canvas gate (the outer READ boundary), so
+*  connecting passes the gate first when a canvas password is set. */
+async function gateCookie(base, canvasPassword) {
+	if (!canvasPassword) return "";
+	const cookie = (await fetch(`${base}/__mv/auth`, {
+		method: "POST",
+		redirect: "manual",
+		headers: { "content-type": "application/x-www-form-urlencoded" },
+		body: `password=${encodeURIComponent(canvasPassword)}&next=`
+	})).headers.getSetCookie?.().find((c) => c.startsWith("mv_a=")) ?? "";
+	const tok = /^mv_a=([^;]+)/.exec(cookie)?.[1];
+	if (!tok) throw new Error("the canvas password was not accepted");
+	return `mv_a=${tok}`;
+}
+async function sessionFrom(res, ctx) {
+	if (!res.ok) {
+		const err = (await res.json().catch(() => null))?.error;
+		throw new Error(err ?? `${ctx} failed (${res.status})`);
+	}
+	const cookie = res.headers.getSetCookie?.().find((c) => c.startsWith("mv_s=")) ?? "";
+	const token = /^mv_s=([\w-]+)/.exec(cookie)?.[1];
+	if (!token) throw new Error("the canvas did not issue a session - is collaboration enabled on it (MARVER_DATA_DIR)?");
+	return token;
+}
+/** Sign in against a published canvas and persist the device credential. The account's
+*  identity rides along: locally-born events carry it as their author snapshot (the
+*  server validates the claim against the session - it never rewrites events). */
+async function connect(root, url, email, password, canvasPassword) {
+	const base = url.replace(/\/+$/, "");
+	const gate = await gateCookie(base, canvasPassword);
+	const res = await fetch(`${base}/__mv/api/auth/signin`, {
+		method: "POST",
+		headers: {
+			"content-type": "application/json",
+			...gate ? { cookie: gate } : {}
+		},
+		body: JSON.stringify({
+			email,
+			password
+		})
+	});
+	if ((res.headers.get("content-type") ?? "").includes("text/html")) throw new Error(`this canvas signs people in with Marver ID, so there is no password to use here.
+  Set MARVER_CLI_TOKEN=\$(openssl rand -hex 24) on the canvas, then run:
+    npx marver comments connect ${base} --token <that same value>`);
+	const token = await sessionFrom(res, "sign-in");
+	const user = (await res.clone().json().catch(() => null))?.user;
+	saveCollab(root, {
+		url: base,
+		token,
+		email: user?.email ?? email,
+		name: user?.name,
+		avatar: user?.avatar
+	});
+}
+/** Claim an invite from the CLI (the dev-first path - no published UI needed). */
+async function connectClaim(root, url, invite, profile, canvasPassword) {
+	const base = url.replace(/\/+$/, "");
+	const gate = await gateCookie(base, canvasPassword);
+	const res = await fetch(`${base}/__mv/api/auth/claim`, {
+		method: "POST",
+		headers: {
+			"content-type": "application/json",
+			...gate ? { cookie: gate } : {}
+		},
+		body: JSON.stringify({
+			token: invite,
+			...profile
+		})
+	});
+	const token = await sessionFrom(res, "claim");
+	const user = (await res.clone().json().catch(() => null))?.user;
+	saveCollab(root, {
+		url: base,
+		token,
+		email: user?.email,
+		name: user?.name ?? profile.name,
+		avatar: user?.avatar
+	});
+}
+/**
+* Connect with the canvas's `MARVER_CLI_TOKEN` - the operator's own credential.
+*
+* The path that works whatever the canvas gates on, and the only one that works
+* when it gates on Marver ID: an identity account has no password for `connect`
+* to present, and the session its sign-in produced lives in an HttpOnly cookie
+* the terminal cannot read. The token is set in the deployment environment
+* rather than handed out by a page, because a page that mints CLI credentials is
+* a page an authored frame can drive - see the note on `operatorUser`.
+*
+* Checked before it is written, so a mistyped token fails here, once, in front
+* of somebody - rather than being persisted and failing on every sync from now
+* on. No canvas password is needed: the token IS gate passage.
+*/
+async function connectToken(root, url, token) {
+	const base = url.replace(/\/+$/, "");
+	if (!token.trim()) throw new Error("that token is empty - is MARVER_CLI_TOKEN set in your shell?");
+	if (token.length < 32) throw new Error(`that token is ${token.length} characters and the canvas will not honour anything under 32.\n  Generate one: MARVER_CLI_TOKEN=\$(openssl rand -hex 24), set it on the canvas, and use the same value here.`);
+	if (!CLI_TOKEN_CHARS.test(token)) throw new Error("that token has characters an Authorization header cannot carry (letters, digits, _ and - only).\n  If it came from `openssl rand -base64`, regenerate it with `openssl rand -hex 24`\n  and set the same value as MARVER_CLI_TOKEN on the canvas.");
+	const res = await fetch(`${base}/__mv/api/cli-session`, {
+		method: "POST",
+		headers: {
+			authorization: `Bearer ${token}`,
+			"content-type": "application/json"
+		},
+		body: "{}"
+	});
+	const html = (res.headers.get("content-type") ?? "").includes("text/html");
+	if (res.status === 404) throw new Error(`${base} has no CLI sign-in - it is running a marver older than 0.11.0`);
+	if (res.status === 401 || html) throw new Error(`the canvas would not accept that token.
+  - is it the same value as MARVER_CLI_TOKEN on ${base}?\n  - has the owner signed in yet? the token acts as the owner, so it does nothing until one exists
+  - is MARVER_DATA_DIR set on the canvas? without it there are no accounts at all
+  - is the canvas running marver 0.11.0 or newer? older ones have no CLI sign-in at all`);
+	if (!res.ok) throw new Error(`the canvas answered ${res.status} - is it up?`);
+	const body = await res.json().catch(() => null);
+	if (!body?.token || !body?.user?.email) throw new Error("the canvas accepted the token but issued nothing - is it running a current marver?");
+	saveCollab(root, {
+		url: base,
+		token: body.token,
+		email: body.user.email,
+		name: body.user.name,
+		avatar: body.user.avatar
+	});
+}
+//#endregion
+export { syncOnce as a, loadCollab as i, connectClaim as n, sync_exports as o, connectToken as r, replay as s, connect as t };

package/dist/update-DuWDj5nR.mjs

@@ -0,0 +1,77 @@
+import { t as __exportAll } from "./rolldown-runtime-D7D4PA-g.mjs";
+import { r as PKG } from "./cli.mjs";
+import { mkdirSync, readFileSync, writeFileSync } from "node:fs";
+import { dirname, join } from "node:path";
+import { fileURLToPath } from "node:url";
+//#region src/server/update.ts
+/**
+* Update discovery - dev only, and deliberately boring about privacy: one anonymous
+* registry metadata GET per day (the same request `npm view` makes), cached in
+* design/.local/, nothing sent beyond the request itself. Offline, slow, or
+* firewalled registries degrade to silence. MARVER_NO_UPDATE_CHECK=1 disables it.
+* Published bundles never check anything - viewers are not the owner.
+*/
+var update_exports = /* @__PURE__ */ __exportAll({
+	checkUpdate: () => checkUpdate,
+	installedVersion: () => installedVersion
+});
+const TTL = 864e5;
+/** Installed version: walk up from this module to the package's own package.json
+*  (one level from dist/, two from src/server/ - the walk covers both). */
+function installedVersion() {
+	let dir = dirname(fileURLToPath(import.meta.url));
+	for (let i = 0; i < 4; i++) {
+		try {
+			const pkg = JSON.parse(readFileSync(join(dir, "package.json"), "utf8"));
+			if (pkg.name === "@marver-design/marver") return pkg.version;
+		} catch {}
+		dir = dirname(dir);
+	}
+	return null;
+}
+/** Strictly-newer numeric compare; anything non-numeric (prerelease tags) compares false. */
+const newer = (a, b) => {
+	const pa = a.split(".").map((n) => parseInt(n, 10));
+	const pb = b.split(".").map((n) => parseInt(n, 10));
+	for (let i = 0; i < 3; i++) {
+		const x = pa[i] ?? 0, y = pb[i] ?? 0;
+		if (!Number.isFinite(x) || !Number.isFinite(y)) return false;
+		if (x !== y) return x > y;
+	}
+	return false;
+};
+/** The latest published version when strictly newer than installed, else null. Never throws. */
+async function checkUpdate(root) {
+	if (process.env.MARVER_NO_UPDATE_CHECK) return null;
+	const current = installedVersion();
+	if (!current) return null;
+	const latest = await latestVersion(root);
+	return latest && newer(latest, current) ? latest : null;
+}
+async function latestVersion(root) {
+	const cacheFile = join(root, "design", ".local", "update-check.json");
+	const wellFormed = (v) => typeof v === "string" && /^\d+\.\d+\.\d+$/.test(v);
+	try {
+		const c = JSON.parse(readFileSync(cacheFile, "utf8"));
+		const age = Date.now() - c.checkedAt;
+		if (typeof c.checkedAt === "number" && age >= 0 && age < TTL) return wellFormed(c.latest) ? c.latest : null;
+	} catch {}
+	let latest = null;
+	try {
+		const res = await fetch(`https://registry.npmjs.org/${encodeURIComponent(PKG)}/latest`, { signal: AbortSignal.timeout(3e3) });
+		if (res.ok) {
+			const v = (await res.json())?.version;
+			if (wellFormed(v)) latest = v;
+		}
+	} catch {}
+	try {
+		mkdirSync(join(root, "design", ".local"), { recursive: true });
+		writeFileSync(cacheFile, JSON.stringify({
+			checkedAt: Date.now(),
+			latest
+		}) + "\n");
+	} catch {}
+	return latest;
+}
+//#endregion
+export { installedVersion as n, update_exports as r, checkUpdate as t };