@marver-design/marver 0.8.1 → 0.10.0

package/dist/{dev-BTAhTie-.mjs → dev-Dv0GlYQq.mjs}

@@ -1,6 +1,6 @@
 import { n as NAME, r as PKG } from "./cli.mjs";
-import { o as loadConfig, s as detectHost } from "./manifest-B4zcDGBf.mjs";
-import { n as tailwind3Css, r as tailwind4Plugin, t as marverPlugin } from "./plugin-BdQEeTLg.mjs";
+import { l as detectHost, s as loadConfig } from "./manifest-DIsp3ldB.mjs";
+import { n as tailwind3Css, r as tailwind4Plugin, t as marverPlugin } from "./plugin-CgLVYTR-.mjs";
 import { basename, dirname, join } from "node:path";
 import { fileURLToPath } from "node:url";
 import { createLogger, createServer, searchForWorkspaceRoot } from "vite";
@@ -170,8 +170,8 @@ async function dev(root, portFlag) {
 			return close();
 		});
 	}
-	if (config.jam?.agent) {
-		const { startJam } = await import("./daemon-DkyNOwIt.mjs");
+	if (config.jam) {
+		const { startJam } = await import("./daemon-B_8BmmSJ.mjs");
 		const jam = startJam(root, config.jam, (m) => console.log(m), (board) => server.ws.send("sh:jam-comment", { board }));
 		if (jam) {
 			const close = server.close.bind(server);
@@ -180,7 +180,7 @@ async function dev(root, portFlag) {
 				return close();
 			});
 		}
-	}
+	} else if (config.jamOff === "no-agent") console.log(`  jam: no agent CLI on PATH (claude, codex, cursor, droid, opencode, grok, or pi) - install one and tag @${NAME} in a comment\n`);
 	return server;
 }
 //#endregion

package/dist/{init-DWdhjJD5.mjs → init-D2EQEbV6.mjs}

@@ -1,5 +1,5 @@
 import { n as NAME } from "./cli.mjs";
-import { a as DEFAULTS, c as readJson, i as writeManifest, r as scanFrames, s as detectHost } from "./manifest-B4zcDGBf.mjs";
+import { a as writeManifest, c as detectAgent, l as detectHost, o as DEFAULTS, r as scanFrames, u as readJson } from "./manifest-DIsp3ldB.mjs";
 import { cpSync, existsSync, mkdirSync, readFileSync, readdirSync, renameSync, rmSync, writeFileSync } from "node:fs";
 import { dirname, join, relative } from "node:path";
 import { fileURLToPath } from "node:url";
@@ -84,7 +84,8 @@ function init(root, opts) {
 			console.warn(`  note: design/${rel} exists without a marver marker - left untouched. If you did not author it, delete it and re-run init to restore the managed version.`);
 		}
 	};
-	write("config.ts", configTemplate(opts.mode));
+	const jamAgent = detectAgent();
+	write("config.ts", configTemplate(opts.mode, jamAgent));
 	if (host.themeCss) {
 		const relCss = relative(design, join(root, host.themeCss)).split("\\").join("/");
 		write("theme.css", themeWrapper(relCss, host.tailwind === 4));
@@ -187,6 +188,8 @@ function init(root, opts) {
 	console.log(`\n  commit design/ - only .local/ is ignored`);
 	console.log(`  uninstall = delete design/, remove the ${NAME} dependency${host.tsconfigSweepsDesign ? ", revert the \"design\" line in tsconfig exclude" : ""}`);
 	if (!noApp(host) && !existsSync(join(design, "DESIGN.md"))) console.log(`\n  note: design/DESIGN.md (the brand doc) does not exist yet - have your agent create it from the app's tokens (instructions/brand.md, Path A) to reach the idle state.`);
+	if (!jamAgent) console.log(`\n  note: Live Jam found no agent CLI on PATH (claude, codex, cursor, droid, opencode, grok, or pi) - install one and it arms itself on the next \`${NAME} dev\`.`);
+	else if (created.includes("design/config.ts")) console.log(`\n  Live Jam is on (${jamAgent}): tag @${NAME} in a canvas comment and your agent does the work, then replies in the thread.`);
 	console.log(`\n  next: npx ${NAME} dev   (or: npx ${NAME} canvas - same thing; canvas on http://localhost:${DEFAULTS.port} by default)\n`);
 	if (!noApp(host)) console.log(`  then, to your agent: "Read design/AGENTS.md. This is our first session - follow design/instructions/welcome.md."\n`);
 }
@@ -339,8 +342,10 @@ npx ${NAME} init
 
 init is idempotent: it detects the real stack, deletes this file, and
 regenerates AGENTS.md against reality. Verify the wiring (instructions/
-configure.md): frames render styled, one app component imports cleanly.
-DESIGN.md comes next, as part of the first draft.
+configure.md): frames render styled, one app component imports cleanly, and
+\`jam.agent\` in design/config.ts names the tool you actually are - Live Jam is
+on by default and init guessed it (instructions/jam.md). DESIGN.md comes next,
+as part of the first draft.
 
 
 ## 6. The path they chose at the fork
@@ -476,7 +481,17 @@ function firstJsonBrace(src) {
 	}
 	return -1;
 }
-const configTemplate = (mode) => `// ${NAME} config - OPTIONAL. Delete this file and everything still works on defaults.
+/** The jam block, written with the agent init detected - or commented out, with the way
+*  to arm it, when this machine has no agent CLI at all. */
+const jamBlock = (agent) => agent ? `  // Live Jam - tag @${NAME} in a canvas comment and this agent picks the job up, edits the
+  // real frame, and replies in the thread. Detected at init; change the agent if it named
+  // the wrong tool, raise concurrency for more frames at once, \`jam: false\` to turn it off.
+  jam: { agent: ${JSON.stringify(agent)}, concurrency: 6 },` : `  // Live Jam - tag @${NAME} in a canvas comment and your coding agent picks the job up,
+  // edits the real frame, and replies in the thread. No agent CLI was on PATH when init ran;
+  // install an agent CLI (claude, codex, cursor, droid, opencode, grok, or pi) and it arms
+  // itself, or name one here. \`jam: false\` turns it off.
+  // jam: { agent: "claude", concurrency: 6 },`;
+const configTemplate = (mode, jamAgent) => `// ${NAME} config - OPTIONAL. Delete this file and everything still works on defaults.
 // Theme lives in design/theme.css (it imports your app's real stylesheet) - not here.
 // Sharp edges (native Node TS import): erasable syntax only (no enums/namespaces),
 // relative imports need extensions, tsconfig paths are ignored here.
@@ -494,6 +509,7 @@ export default {
   port: ${DEFAULTS.port},
   // Canvas zoom feel: 1 = default, 1.2 = 20% faster, 0.8 = 20% slower.
   // zoomSpeed: 1,
+${jamBlock(jamAgent)}
   // Publishing (\`${NAME} build\` + \`${NAME} serve\`): gate identity + branding footer.
   // name/logo default to the host package.json name and design/logo.svg (then public/).
   // branding is the small "Powered by Marver.design" line under the gate. Marver is

package/dist/ledger-BgA7nQoH.mjs

@@ -0,0 +1,103 @@
+import { closeSync, existsSync, fsyncSync, mkdirSync, openSync, readFileSync, writeSync } from "node:fs";
+import { dirname, join } from "node:path";
+import { createHash } from "node:crypto";
+import { homedir, hostname, userInfo } from "node:os";
+//#region \0rolldown/runtime.js
+var __defProp = Object.defineProperty;
+var __exportAll = (all, no_symbols) => {
+	let target = {};
+	for (var name in all) __defProp(target, name, {
+		get: all[name],
+		enumerable: true
+	});
+	if (!no_symbols) __defProp(target, Symbol.toStringTag, { value: "Module" });
+	return target;
+};
+//#endregion
+//#region src/server/jam/device.ts
+/**
+* The device stamp - what makes "device-bound" true for the two files that decide whether
+* a comment may spawn an agent (the ledger and the journal).
+*
+* Both live in design/.local/, which is gitignored and never synced. But gitignore is a
+* convention, not provenance: a repo can force-add its own design/.local/ and hand a clone
+* a pre-authorized ledger plus a pre-baselined journal, and the daemon would run jobs the
+* owner never wrote. Stamping the files with THIS machine means a cloned one matches
+* nothing and is treated as absent.
+*
+* Derived, never stored: marver's whole uninstall story is "delete design/", so it writes
+* no state outside the repo. The trade is that the stamp is a hash of public facts, so it
+* is guessable by someone who already knows the target's hostname and username. It defeats
+* one repo published to everyone, not a stranger who knows your machine. The bigger lever in
+* that scenario is unchanged either way: design/config.ts is imported and executed by
+* `marver dev`, so running a dev server in a repo you do not trust is already running its code.
+*/
+let cached;
+/** A short, stable id for this machine + user. */
+function deviceId() {
+	if (cached) return cached;
+	let who = "";
+	try {
+		who = userInfo().username;
+	} catch {}
+	return cached = createHash("sha256").update([
+		hostname(),
+		who,
+		homedir()
+	].join("\0")).digest("hex").slice(0, 16);
+}
+//#endregion
+//#region src/server/jam/ledger.ts
+/**
+* The device-bound authorization ledger - the whole trust boundary.
+*
+* When the dev POST accepts an owner-gated write, it records that event's id here. The
+* daemon's owner-trigger check is `has(root, id)`, never a synced field: sync copies
+* `origin` byte-for-byte, so a remote comment can spoof `origin:'local'` (proven RCE),
+* but it can never appear in a file that is written only on THIS machine by the gated
+* POST and never synced. Synced-in events are never in the ledger, so they never trigger.
+*
+* One `<device>\t<board>\t<id>` per line, append-only, gitignored, never synced (design/.local/
+* is watch-ignored and sync-excluded). Agent-written events are never recorded (they are
+* daemon-authored, not owner input, so they cannot self-authorize a next job).
+*
+* The key is (device, board, id), never id alone:
+* - board, because event ids are client UUIDs that sync copies verbatim, so a remote
+*   collaborator could reuse an owner's ledgered id in a NEW malicious event. Binding to the
+*   board it was gate-written on defeats that - the forged copy lands on some board the ledger
+*   never authorized for that id, so it never triggers.
+* - device, because gitignore is a convention, not provenance: a repo can force-add its own
+*   design/.local/ and hand a clone a ledger full of pre-authorized ids. Lines stamped with
+*   another machine match nothing here (device.ts).
+*/
+var ledger_exports = /* @__PURE__ */ __exportAll({
+	has: () => has,
+	record: () => record
+});
+const ledgerFile = (root) => join(root, "design", ".local", "jam-ledger");
+const line = (board, id) => `${deviceId()}\t${board}\t${id}`;
+/** Was this (board, id) authorized on this device by the gated dev POST? */
+function has(root, board, id) {
+	if (!board || !id) return false;
+	const file = ledgerFile(root);
+	if (!existsSync(file)) return false;
+	const want = line(board, id);
+	for (const l of readFileSync(file, "utf8").split("\n")) if (l === want) return true;
+	return false;
+}
+/** Authorize a (board, id). fsync'd (a 200-acked, ledgered write must survive a crash) and
+*  0600 (owner-only). Idempotent enough: a duplicate line is harmless, `has` matches either. */
+function record(root, board, id) {
+	if (!board || !id) return;
+	const file = ledgerFile(root);
+	mkdirSync(dirname(file), { recursive: true });
+	const fd = openSync(file, "a", 384);
+	try {
+		writeSync(fd, line(board, id) + "\n");
+		fsyncSync(fd);
+	} finally {
+		closeSync(fd);
+	}
+}
+//#endregion
+export { ledger_exports as n, deviceId as r, has as t };

package/dist/{manifest-B4zcDGBf.mjs → manifest-DIsp3ldB.mjs}

@@ -1,6 +1,6 @@
 import { r as PKG, t as CONTENT_WIDTH } from "./cli.mjs";
-import { existsSync, mkdirSync, readFileSync, readdirSync, writeFileSync } from "node:fs";
-import { join, relative, sep } from "node:path";
+import { accessSync, constants, existsSync, mkdirSync, readFileSync, readdirSync, statSync, writeFileSync } from "node:fs";
+import { delimiter, isAbsolute, join, relative, sep } from "node:path";
 import { pathToFileURL } from "node:url";
 import { createHash } from "node:crypto";
 //#region src/server/detect.ts
@@ -125,6 +125,99 @@ function firstExisting(root, candidates) {
 	return null;
 }
 //#endregion
+//#region src/server/jam/agent.ts
+/**
+* Which coding agent drives this repo.
+*
+* Live Jam is ON by default, so this is the answer to "on by default with WHAT" - asked
+* once by `init` (which writes the answer into design/config.ts, where it is visible and
+* editable) and again at every dev boot, so a workspace that predates the block - or a
+* human who switched tools - still jams without editing anything.
+*
+* The tool RUNNING us wins: `init` is usually run BY the agent, so its env markers are
+* evidence rather than a guess. Whatever wins must still be on PATH - the daemon has to
+* spawn it.
+*/
+/** Ordered by preference when a machine has several installed and none is running us. */
+const AGENTS = [
+	"claude",
+	"codex",
+	"cursor",
+	"droid",
+	"opencode",
+	"grok",
+	"pi"
+];
+/** Env vars each CLI sets in the processes it spawns. Deliberately NOT CODEX_HOME or
+*  ANTHROPIC_API_KEY: those are configuration a human exports by hand, not evidence that
+*  the tool is running right now. (opencode's `AGENT=1` and pi's `AI_AGENT` are skipped
+*  for the same reason in reverse - too generic to prove WHICH tool is running.)
+*  droid and grok set no marker at all in the shells they spawn (verified against the
+*  grok-build source and droid 0.200.0), so they are found by PATH order only. */
+const MARKERS = {
+	claude: ["CLAUDECODE", "CLAUDE_CODE_ENTRYPOINT"],
+	codex: ["CODEX_SANDBOX", "CODEX_THREAD_ID"],
+	cursor: ["CURSOR_AGENT"],
+	droid: [],
+	opencode: ["OPENCODE", "OPENCODE_PID"],
+	grok: [],
+	pi: ["PI_CODING_AGENT", "PI_SESSION_ID"]
+};
+/** The executable each agent name maps to. Only cursor differs: its CLI installs BOTH
+*  `cursor-agent` and a bare `agent` - and grok's installer symlinks `agent` too, so the
+*  short name is a coin flip on a machine with both. The long name is unambiguous. */
+const AGENT_BIN = {
+	claude: "claude",
+	codex: "codex",
+	cursor: "cursor-agent",
+	droid: "droid",
+	opencode: "opencode",
+	grok: "grok",
+	pi: "pi"
+};
+/** The valid `jam.agent` values as an English list - one string, so every surface
+*  (config warning, init note, dev boot line) names the same set and none goes stale. */
+const AGENT_NAMES = `${AGENTS.slice(0, -1).map((a) => `"${a}"`).join(", ")}, or "${AGENTS[AGENTS.length - 1]}"`;
+/** Is `cmd` an executable FILE on PATH? A direct stat per PATH entry - no spawn, no shell,
+*  so this is safe to call on every dev boot. Two deliberate narrowings, both in service of
+*  "found means spawnable", because arming an agent that cannot run is worse than staying off:
+*
+*  - `isFile`, because a directory carries the execute bit too (it means "traversable"), so an
+*    access check alone would call a folder named `claude` an agent.
+*  - the bare name only, no PATHEXT: the daemon spawns without a shell, and Node cannot run a
+*    Windows `.cmd`/`.bat` shim that way. Finding one would arm a job that fails on every run.
+*
+*  Only ABSOLUTE PATH entries count. An empty entry means the current directory on POSIX, and
+*  a relative one (`.`, `bin`) resolves against it too - and the current directory is the repo
+*  that was just opened, so a `claude` binary shipped inside it is precisely what must never
+*  be found and spawned. */
+function onPath(cmd, env = process.env) {
+	for (const dir of (env.PATH ?? "").split(delimiter)) {
+		if (!isAbsolute(dir)) continue;
+		try {
+			const file = join(dir, cmd);
+			if (statSync(file).isFile()) {
+				accessSync(file, constants.X_OK);
+				return true;
+			}
+		} catch {}
+	}
+	return false;
+}
+/** The agent to jam with, or undefined when this machine has none installed.
+*
+*  One knowingly-imperfect case: agents nest, and env is inherited, so a codex run started
+*  FROM Claude Code carries both marker families and this picks claude. Env has no depth to
+*  read, and walking the process tree to find the nearest agent ancestor costs more than the
+*  case is worth - so the answer is made visible instead of clever: `init` prints the agent
+*  it chose and writes it into design/config.ts, and instructions/jam.md has the agent confirm
+*  that line names the tool it actually is. One word to correct, once per repo. */
+function detectAgent(env = process.env) {
+	const running = AGENTS.find((a) => MARKERS[a].some((k) => env[k]));
+	if (running && onPath(AGENT_BIN[running], env)) return running;
+	return AGENTS.find((a) => onPath(AGENT_BIN[a], env));
+}
+//#endregion
 //#region src/server/config.ts
 const DEFAULTS = {
 	mode: "studio",
@@ -155,7 +248,10 @@ const DEFAULTS = {
 /** Load design/config.ts via native TS import (Node >= 22.18). Missing or broken fields fall back to defaults. */
 async function loadConfig(root) {
 	const file = join(root, "design", "config.ts");
-	if (!existsSync(file)) return { ...DEFAULTS };
+	if (!existsSync(file)) return {
+		...DEFAULTS,
+		...jamFields(void 0)
+	};
 	try {
 		const user = (await import(`${pathToFileURL(file).href}?t=${Date.now()}`)).default ?? {};
 		return {
@@ -170,11 +266,14 @@ async function loadConfig(root) {
 				name: typeof user.share?.name === "string" ? user.share.name : void 0,
 				logo: typeof user.share?.logo === "string" ? user.share.logo : void 0
 			},
-			jam: validJam(user.jam)
+			...jamFields(user.jam)
 		};
 	} catch (err) {
-		console.error(`[marver] design/config.ts failed to load, using defaults:\n  ${err.message}`);
-		return { ...DEFAULTS };
+		console.error(`[marver] design/config.ts failed to load, using defaults and leaving Live Jam OFF:\n  ${err.message}`);
+		return {
+			...DEFAULTS,
+			jamOff: "unreadable"
+		};
 	}
 }
 const validDim = (n) => typeof n === "number" && Number.isFinite(n) && n >= 1 && n <= 2e4;
@@ -184,20 +283,78 @@ function validPort(n) {
 function validZoom(n) {
 	return typeof n === "number" && Number.isFinite(n) && n >= .1 && n <= 10 ? n : null;
 }
-/** Normalize the jam block. An unknown/missing `agent` means Live Jam stays OFF (returns undefined),
-*  so a stray `jam: {}` never silently arms the daemon. Other fields fall back to lean defaults. */
-function validJam(v) {
-	if (!v || typeof v !== "object") return void 0;
-	const j = v;
-	if (j.agent !== "claude" && j.agent !== "codex") return void 0;
-	const concurrency = typeof j.concurrency === "number" && Number.isInteger(j.concurrency) && j.concurrency >= 1 && j.concurrency <= 16 ? j.concurrency : 3;
+/** Six frames at once is what a jam actually feels like - at 3, half of a multi-frame
+*  ask sat waiting on the other half while the human watched. */
+const DEFAULT_CONCURRENCY = 6;
+/** A config value, printable in a warning. Never throws - a formatter that can crash inside an
+*  error path (JSON.stringify does, on a BigInt) turns a clear message into a mystery. */
+const show = (v) => {
+	try {
+		return JSON.stringify(v) ?? String(v);
+	} catch {
+		return String(v);
+	}
+};
+/** A `{...}` written by hand, not a Date/Map/class instance that merely types as "object". */
+const plainObject = (v) => {
+	if (!v || typeof v !== "object") return false;
+	const proto = Object.getPrototypeOf(v);
+	return proto === Object.prototype || proto === null;
+};
+/** The agent to arm with - or, when the human NAMED one we cannot use, why not (said once,
+*  here, because a bad `jam.agent` is a config-file error like any other).
+*
+*  A named agent is never quietly swapped for another: running a different tool than the one
+*  asked for is worse than not running. Nor is one armed that cannot be spawned - that would
+*  claim every @marver mention, fail it, and never retry. */
+function resolveAgent(named) {
+	if (named === void 0) return detectAgent() ?? "no-agent";
+	if (typeof named !== "string" || !Object.hasOwn(AGENT_BIN, named)) {
+		console.warn(`[marver] design/config.ts: jam.agent ${show(named)} is not an agent marver can spawn - Live Jam is off. Use ${AGENT_NAMES}.`);
+		return "bad-agent";
+	}
+	const agent = named;
+	if (!onPath(AGENT_BIN[agent])) {
+		console.warn(`[marver] design/config.ts names jam.agent "${agent}", but \`${AGENT_BIN[agent]}\` is not on PATH - Live Jam is off until it is installed.`);
+		return "bad-agent";
+	}
+	return agent;
+}
+/** Resolve the jam block. Live Jam is ON by default: an absent or partial `jam` resolves
+*  to whatever agent CLI this machine has, so a fresh workspace jams with nothing
+*  configured and an old one needs no re-init. `jam: false` is the off switch. */
+function resolveJam(v) {
+	if (v === false) return "opted-out";
+	const shape = v === void 0 || v === true ? {} : typeof v === "string" ? { agent: v } : plainObject(v) ? v : null;
+	if (!shape) {
+		console.warn(`[marver] design/config.ts: jam must be false, an agent name, or an options object - got ${show(v)}. Live Jam is off.`);
+		return "bad-agent";
+	}
+	const j = shape;
+	const agent = resolveAgent(j.agent);
+	if (agent === "no-agent" || agent === "bad-agent") return agent;
+	const c = j.concurrency;
 	return {
-		agent: j.agent,
-		concurrency,
+		agent,
+		concurrency: typeof c === "number" && Number.isInteger(c) && c >= 1 && c <= 16 ? c : DEFAULT_CONCURRENCY,
 		subagents: j.subagents !== false,
 		proactive: j.proactive === true
 	};
 }
+/** Exactly one of `jam` (armed) or `jamOff` (why not) - so the dev server can speak up about
+*  the one off-state nothing has reported yet, and stay quiet about the rest. BOTH keys are
+*  always written: these spread over the user's own `jam`, and a raw `jam: false` reaching the
+*  server as config would arm the daemon against a truthy object check. */
+function jamFields(v) {
+	const r = resolveJam(v);
+	return typeof r === "string" ? {
+		jam: void 0,
+		jamOff: r
+	} : {
+		jam: r,
+		jamOff: void 0
+	};
+}
 function validViewports(v) {
 	if (!v || typeof v !== "object") return null;
 	const out = {};
@@ -439,4 +596,4 @@ function writeManifest(root, manifest) {
 }
 const hash = (s) => createHash("sha256").update(s).digest("hex");
 //#endregion
-export { DEFAULTS as a, readJson as c, writeManifest as i, hash as n, loadConfig as o, scanFrames as r, detectHost as s, affectedFrameIds as t };
+export { writeManifest as a, detectAgent as c, toFrameId as i, detectHost as l, hash as n, DEFAULTS as o, scanFrames as r, loadConfig as s, affectedFrameIds as t, readJson as u };

package/dist/{plugin-BdQEeTLg.mjs → plugin-CgLVYTR-.mjs}

@@ -1,6 +1,6 @@
 import { i as ROUTE, n as NAME, r as PKG } from "./cli.mjs";
 import { n as localProfile, t as isConnected } from "./profile-BkiWglVE.mjs";
-import { i as writeManifest, n as hash, r as scanFrames, t as affectedFrameIds } from "./manifest-B4zcDGBf.mjs";
+import { a as writeManifest, n as hash, r as scanFrames, t as affectedFrameIds } from "./manifest-DIsp3ldB.mjs";
 import { copyFileSync, existsSync, mkdirSync, readFileSync, readdirSync, realpathSync, renameSync, rmSync, watch, writeFileSync } from "node:fs";
 import { basename, dirname, join, resolve, sep } from "node:path";
 import { fileURLToPath } from "node:url";
@@ -82,7 +82,7 @@ function contained(target, base) {
 		return false;
 	}
 }
-function apiMiddleware(root) {
+function apiMiddleware(root, opts = {}) {
 	const boardsDir = join(root, "design", "boards");
 	const boardPath = (name) => {
 		if (!BOARD_NAME.test(name)) return null;
@@ -167,6 +167,30 @@ function apiMiddleware(root) {
 					return json(res, 200, { sha256: hash(next2) });
 				}
 			}
+			if (path === "shot" && req.method === "GET") {
+				const { readDevInfo } = await import("./work-CLrmY-vQ.mjs");
+				const token = readDevInfo(root)?.token;
+				if (!ownerGated(req) && !(token && req.headers["x-mv-work"] === token)) return json(res, 403, { error: "forbidden" });
+				const frameId = url.searchParams.get("frame") ?? "";
+				const theme = url.searchParams.get("theme") ?? "light";
+				const origin = opts.origin?.() ?? `http://${req.headers.host ?? "localhost"}`;
+				const { shootFrame } = await import("./shot-BRgPaFCs.mjs");
+				const r = await shootFrame({
+					root,
+					viewports: opts.viewports ?? {},
+					frameId,
+					theme,
+					origin
+				});
+				if (!r.ok) return json(res, r.error.startsWith("unknown frame") ? 404 : r.error === "invalid theme" ? 400 : 503, { error: r.error });
+				return json(res, 200, {
+					path: r.path,
+					frame: frameId,
+					theme,
+					width: r.width,
+					height: r.height
+				});
+			}
 			if (path === "me" && req.method === "GET") return json(res, 200, {
 				user: localProfile(root),
 				role: "owner",
@@ -269,7 +293,7 @@ function apiMiddleware(root) {
 						};
 					});
 					const fresh = appendEvents(dir, cm[1], stamped);
-					const { record } = await import("./ledger-CbzTJrV2.mjs").then((n) => n.n);
+					const { record } = await import("./ledger-BgA7nQoH.mjs").then((n) => n.n);
 					for (const ev of fresh) if (ev.type === "create" || ev.type === "reply") record(root, cm[1], ev.id);
 					backgroundPush(root);
 					return json(res, 200, { accepted: fresh.length });
@@ -565,7 +589,15 @@ function marverPlugin(ctx) {
 					}));
 				});
 			});
-			server.middlewares.use(apiMiddleware(root));
+			const listeningOrigin = () => {
+				const a = server.httpServer?.address();
+				if (!a || typeof a === "string") return null;
+				return `http://${a.family === "IPv6" ? a.address === "::" ? "[::1]" : `[${a.address}]` : a.address === "0.0.0.0" ? "127.0.0.1" : a.address}:${a.port}`;
+			};
+			server.middlewares.use(apiMiddleware(root, {
+				viewports: config.viewports,
+				origin: listeningOrigin
+			}));
 			server.middlewares.use(routesMiddleware(server, clientDir));
 			devServer = server;
 			const regen = debounce(() => {
@@ -630,6 +662,71 @@ function marverPlugin(ctx) {
 				});
 				server.httpServer?.once("close", () => watcher.close());
 			} catch {}
+			try {
+				const inbox = join(root, "design", ".local", "shots");
+				mkdirSync(inbox, { recursive: true });
+				const origin = listeningOrigin;
+				const inFlight = /* @__PURE__ */ new Set();
+				const processRequest = (file) => {
+					if (!file.endsWith(".request.json") || inFlight.has(file)) return;
+					const reqPath = join(inbox, file);
+					if (!existsSync(reqPath)) return;
+					inFlight.add(file);
+					setTimeout(async () => {
+						try {
+							let spec;
+							try {
+								spec = JSON.parse(readFileSync(reqPath, "utf8"));
+							} catch {
+								return;
+							}
+							const base = file.replace(/\.request\.json$/, "");
+							const resultPath = join(inbox, `${base}.result.json`);
+							const frameId = typeof spec.frame === "string" ? spec.frame : "";
+							const theme = typeof spec.theme === "string" ? spec.theme : "light";
+							const o = origin();
+							const write = (r) => {
+								try {
+									writeFileSync(resultPath, JSON.stringify(r, null, 2));
+								} catch {}
+							};
+							if (!o) {
+								write({
+									ok: false,
+									error: "dev server has no address yet - retry"
+								});
+								return;
+							}
+							const { shootFrame } = await import("./shot-BRgPaFCs.mjs");
+							write(await shootFrame({
+								root,
+								viewports: config.viewports,
+								frameId,
+								theme,
+								origin: o
+							}));
+							try {
+								rmSync(reqPath, { force: true });
+							} catch {}
+						} finally {
+							inFlight.delete(file);
+						}
+					}, 60);
+				};
+				const inboxWatcher = watch(inbox, { persistent: false }, (_e, file) => {
+					if (file) processRequest(file);
+				});
+				const sweep = setInterval(() => {
+					try {
+						for (const f of readdirSync(inbox)) processRequest(f);
+					} catch {}
+				}, 1e3);
+				sweep.unref?.();
+				server.httpServer?.once("close", () => {
+					inboxWatcher.close();
+					clearInterval(sweep);
+				});
+			} catch {}
 		}
 	};
 }