poseref 0.1.0

package/dist-server/cli.js

@@ -0,0 +1,2601 @@
+#!/usr/bin/env node
+import { closeSync, copyFileSync, createReadStream, existsSync, mkdirSync, openSync, readFileSync, writeFileSync, writeSync } from "node:fs";
+import { dirname, extname, join, normalize, resolve, sep } from "node:path";
+import { fileURLToPath } from "node:url";
+import { serveStdio } from "@modelcontextprotocol/server/stdio";
+import { readdir, rm, stat, writeFile } from "node:fs/promises";
+import { createServer } from "node:http";
+import { localhostHostValidation, localhostOriginValidation, toNodeHandler } from "@modelcontextprotocol/node";
+import { WebSocketServer } from "ws";
+import { createHash, createHmac, randomBytes, timingSafeEqual } from "node:crypto";
+import { homedir } from "node:os";
+import * as z from "zod";
+import { McpServer, createMcpHandler } from "@modelcontextprotocol/server";
+import { Euler, Matrix4, Quaternion, Vector3 } from "three";
+import { spawn, spawnSync } from "node:child_process";
+import { createInterface } from "node:readline/promises";
+//#region server/bridge.ts
+var REQUEST_TIMEOUT_MS$1 = 2e4;
+/** Thrown when no browser tab is connected; the message is meant for the agent to relay. */
+var NoBrowserError = class extends Error {};
+/**
+* Tracks the PoseRef browser tabs connected over WebSocket and forwards agent
+* requests to one of them. The tab that most recently gained focus wins, so
+* with several tabs open the agent edits the one the user is looking at.
+*/
+var BrowserBridge = class {
+	tabs = [];
+	pending = /* @__PURE__ */ new Map();
+	nextId = 1;
+	appUrl;
+	constructor(appUrl) {
+		this.appUrl = appUrl;
+	}
+	get connectedTabs() {
+		return this.tabs.length;
+	}
+	attach(socket) {
+		this.tabs.push(socket);
+		socket.on("message", (data) => this.handleMessage(socket, String(data)));
+		socket.on("close", () => this.detach(socket));
+		socket.on("error", () => socket.close());
+	}
+	request(method, params) {
+		const socket = this.tabs[this.tabs.length - 1];
+		if (!socket) return Promise.reject(new NoBrowserError(`No PoseRef browser tab is connected. Ask the user to open ${this.appUrl} in a browser, then retry. If that page does not load, PoseRef is not running: the user can start it with \`npx poseref\`.`));
+		const id = this.nextId++;
+		const message = {
+			type: "request",
+			id,
+			method,
+			params
+		};
+		return new Promise((resolve, reject) => {
+			const timer = setTimeout(() => {
+				this.pending.delete(id);
+				reject(/* @__PURE__ */ new Error("The PoseRef browser tab did not answer in time. Ask the user to check that the tab is still open."));
+			}, REQUEST_TIMEOUT_MS$1);
+			this.pending.set(id, {
+				socket,
+				resolve,
+				reject,
+				timer
+			});
+			socket.send(JSON.stringify(message));
+		});
+	}
+	closeAll() {
+		for (const socket of this.tabs) socket.terminate();
+	}
+	handleMessage(socket, raw) {
+		let message;
+		try {
+			message = JSON.parse(raw);
+		} catch {
+			return;
+		}
+		if (message.type === "focus") {
+			const index = this.tabs.indexOf(socket);
+			if (index >= 0) this.tabs.push(...this.tabs.splice(index, 1));
+			return;
+		}
+		if (message.type !== "response") return;
+		const entry = this.pending.get(message.id);
+		if (!entry || entry.socket !== socket) return;
+		this.pending.delete(message.id);
+		clearTimeout(entry.timer);
+		if (message.ok) entry.resolve(message.result);
+		else entry.reject(new Error(message.error));
+	}
+	detach(socket) {
+		const index = this.tabs.indexOf(socket);
+		if (index >= 0) this.tabs.splice(index, 1);
+		for (const [id, entry] of this.pending) {
+			if (entry.socket !== socket) continue;
+			this.pending.delete(id);
+			clearTimeout(entry.timer);
+			entry.reject(/* @__PURE__ */ new Error("The PoseRef browser tab was closed before it answered."));
+		}
+	}
+};
+//#endregion
+//#region server/home.ts
+/**
+* Per-user folder for the shared secret and review renders. It lives in the
+* home directory rather than the system temp folder, which other users can
+* read (and pre-create paths in) on Linux and macOS. POSEREF_HOME overrides it,
+* mainly for tests.
+*/
+function poserefHome() {
+	return process.env.POSEREF_HOME || join(homedir(), ".poseref");
+}
+/** Creates the folder if needed, readable only by the current user where the OS supports modes. */
+function ensurePrivateDir(path) {
+	mkdirSync(path, {
+		recursive: true,
+		mode: 448
+	});
+	return path;
+}
+function secretPath() {
+	return join(poserefHome(), "secret");
+}
+function rendersDir() {
+	return ensurePrivateDir(join(ensurePrivateDir(poserefHome()), "renders"));
+}
+//#endregion
+//#region server/auth.ts
+/**
+* A per-user secret shared by the long-running PoseRef server and the stdio MCP
+* processes that agents start. It lets those processes (1) prove the listener
+* on the PoseRef port really is PoseRef before sending it anything, and (2)
+* call the server's internal bridge endpoint, which other local users and web
+* pages cannot. The file is created once, exclusively, with owner-only access.
+*/
+var SECRET_BYTES = 32;
+function loadOrCreateSecret(path = secretPath()) {
+	ensurePrivateDir(poserefHome());
+	try {
+		const fd = openSync(path, "wx", 384);
+		try {
+			writeSync(fd, randomBytes(SECRET_BYTES).toString("hex"));
+		} finally {
+			closeSync(fd);
+		}
+	} catch (error) {
+		if (error.code !== "EEXIST") throw error;
+	}
+	const secret = Buffer.from(readFileSync(path, "utf8").trim(), "hex");
+	if (secret.length !== SECRET_BYTES) throw new Error(`The PoseRef secret at ${path} is damaged. Delete it and start PoseRef again.`);
+	return secret;
+}
+function newNonce() {
+	return randomBytes(16).toString("hex");
+}
+function isValidNonce(nonce) {
+	return /^[0-9a-f]{32}$/.test(nonce);
+}
+/** The server's answer to a nonce: only a holder of the secret can compute it. */
+function identityProof(secret, nonce) {
+	return createHmac("sha256", secret).update(`poseref-identify:${nonce}`).digest("hex");
+}
+/** Compares digests so neither length nor content leaks through timing. */
+function sameDigest(a, b) {
+	const left = createHash("sha256").update(a).digest();
+	const right = createHash("sha256").update(b).digest();
+	return timingSafeEqual(left, right);
+}
+function verifyIdentityProof(secret, nonce, proof) {
+	return typeof proof === "string" && sameDigest(identityProof(secret, nonce), proof);
+}
+function bearerToken(secret) {
+	return secret.toString("hex");
+}
+function bearerMatches(secret, header) {
+	const match = /^Bearer ([0-9a-f]+)$/.exec(header ?? "");
+	return match !== null && sameDigest(bearerToken(secret), match[1]);
+}
+//#endregion
+//#region src/constants/aspectRatios.ts
+/** Supported aspect ratios with their 1024px-basis export sizes. */
+var ASPECT_RATIOS = [
+	{
+		id: "1:1",
+		label: "1:1",
+		width: 1024,
+		height: 1024
+	},
+	{
+		id: "16:9",
+		label: "16:9",
+		width: 1024,
+		height: 576
+	},
+	{
+		id: "9:16",
+		label: "9:16",
+		width: 576,
+		height: 1024
+	},
+	{
+		id: "4:3",
+		label: "4:3",
+		width: 1024,
+		height: 768
+	},
+	{
+		id: "3:4",
+		label: "3:4",
+		width: 768,
+		height: 1024
+	}
+];
+Object.fromEntries(ASPECT_RATIOS.map((option) => [option.id, option]));
+//#endregion
+//#region src/constants/bones.ts
+/** Base height of the hips pivot above the floor (meters). */
+var HIPS_BASE_Y = .94;
+/**
+* Bone hierarchy. Pivots are expressed relative to the parent pivot.
+* The character faces +Z, +X is the left side of the character, +Y is up.
+* Limb meshes extend along local -Y from their pivot.
+*/
+var BONES = [
+	{
+		id: "hips",
+		label: "腰",
+		parent: null,
+		offset: {
+			x: 0,
+			y: HIPS_BASE_Y,
+			z: 0
+		}
+	},
+	{
+		id: "chest",
+		label: "胸",
+		parent: "hips",
+		offset: {
+			x: 0,
+			y: .07,
+			z: 0
+		}
+	},
+	{
+		id: "neck",
+		label: "首",
+		parent: "chest",
+		offset: {
+			x: 0,
+			y: .43,
+			z: 0
+		}
+	},
+	{
+		id: "head",
+		label: "頭",
+		parent: "neck",
+		offset: {
+			x: 0,
+			y: .08,
+			z: 0
+		}
+	},
+	{
+		id: "leftShoulder",
+		label: "左肩",
+		parent: "chest",
+		offset: {
+			x: .07,
+			y: .38,
+			z: 0
+		}
+	},
+	{
+		id: "rightShoulder",
+		label: "右肩",
+		parent: "chest",
+		offset: {
+			x: -.07,
+			y: .38,
+			z: 0
+		}
+	},
+	{
+		id: "leftUpperArm",
+		label: "左上腕",
+		parent: "leftShoulder",
+		offset: {
+			x: .14,
+			y: 0,
+			z: 0
+		}
+	},
+	{
+		id: "rightUpperArm",
+		label: "右上腕",
+		parent: "rightShoulder",
+		offset: {
+			x: -.14,
+			y: 0,
+			z: 0
+		}
+	},
+	{
+		id: "leftForearm",
+		label: "左前腕",
+		parent: "leftUpperArm",
+		offset: {
+			x: 0,
+			y: -.28,
+			z: 0
+		}
+	},
+	{
+		id: "rightForearm",
+		label: "右前腕",
+		parent: "rightUpperArm",
+		offset: {
+			x: 0,
+			y: -.28,
+			z: 0
+		}
+	},
+	{
+		id: "leftHand",
+		label: "左手",
+		parent: "leftForearm",
+		offset: {
+			x: 0,
+			y: -.26,
+			z: 0
+		}
+	},
+	{
+		id: "rightHand",
+		label: "右手",
+		parent: "rightForearm",
+		offset: {
+			x: 0,
+			y: -.26,
+			z: 0
+		}
+	},
+	{
+		id: "leftThigh",
+		label: "左太もも",
+		parent: "hips",
+		offset: {
+			x: .095,
+			y: -.06,
+			z: 0
+		}
+	},
+	{
+		id: "rightThigh",
+		label: "右太もも",
+		parent: "hips",
+		offset: {
+			x: -.095,
+			y: -.06,
+			z: 0
+		}
+	},
+	{
+		id: "leftLowerLeg",
+		label: "左すね",
+		parent: "leftThigh",
+		offset: {
+			x: 0,
+			y: -.4,
+			z: 0
+		}
+	},
+	{
+		id: "rightLowerLeg",
+		label: "右すね",
+		parent: "rightThigh",
+		offset: {
+			x: 0,
+			y: -.4,
+			z: 0
+		}
+	}
+];
+var BONE_MAP = Object.fromEntries(BONES.map((bone) => [bone.id, bone]));
+var BONE_IDS = BONES.map((bone) => bone.id);
+var sided = (side, bone) => `${side}${bone}`;
+function sidedLandmarks(name, bone, offset, chain) {
+	const title = name[0].toUpperCase() + name.slice(1);
+	return ["left", "right"].map((side) => ({
+		id: `${side}${title}`,
+		bone: sided(side, bone),
+		offset,
+		ikChain: chain.map((name) => sided(side, name))
+	}));
+}
+/**
+* Points an AI agent can measure to check contact and grounding, or move with
+* the `reach` IK tool. Offsets are in the bone's local space and follow the
+* shapes in MANNEQUIN_PARTS (head ellipsoid, hand ellipsoid, foot on the lower
+* leg), so update both together. `ikChain` lists the bones IK rotates by
+* default to move the point, root side first; the pelvis and hips have none
+* because moving them means moving the whole body.
+*/
+var JOINT_LANDMARKS = [
+	{
+		id: "pelvis",
+		bone: "hips",
+		offset: {
+			x: 0,
+			y: 0,
+			z: 0
+		},
+		ikChain: []
+	},
+	{
+		id: "neckBase",
+		bone: "neck",
+		offset: {
+			x: 0,
+			y: 0,
+			z: 0
+		},
+		ikChain: ["chest"]
+	},
+	{
+		id: "headCenter",
+		bone: "head",
+		offset: {
+			x: 0,
+			y: .12,
+			z: 0
+		},
+		ikChain: ["neck", "head"]
+	},
+	{
+		id: "headTop",
+		bone: "head",
+		offset: {
+			x: 0,
+			y: .24,
+			z: 0
+		},
+		ikChain: ["neck", "head"]
+	},
+	{
+		id: "chin",
+		bone: "head",
+		offset: {
+			x: 0,
+			y: .02,
+			z: .06
+		},
+		ikChain: ["neck", "head"]
+	},
+	{
+		id: "nose",
+		bone: "head",
+		offset: {
+			x: 0,
+			y: .1,
+			z: .13
+		},
+		ikChain: ["neck", "head"]
+	},
+	...sidedLandmarks("shoulder", "UpperArm", {
+		x: 0,
+		y: 0,
+		z: 0
+	}, ["Shoulder"]),
+	...sidedLandmarks("elbow", "Forearm", {
+		x: 0,
+		y: 0,
+		z: 0
+	}, ["UpperArm"]),
+	...sidedLandmarks("wrist", "Hand", {
+		x: 0,
+		y: 0,
+		z: 0
+	}, ["UpperArm", "Forearm"]),
+	...sidedLandmarks("palm", "Hand", {
+		x: 0,
+		y: -.085,
+		z: 0
+	}, ["UpperArm", "Forearm"]),
+	...sidedLandmarks("fingertips", "Hand", {
+		x: 0,
+		y: -.18,
+		z: 0
+	}, ["UpperArm", "Forearm"]),
+	...sidedLandmarks("hip", "Thigh", {
+		x: 0,
+		y: 0,
+		z: 0
+	}, []),
+	...sidedLandmarks("knee", "LowerLeg", {
+		x: 0,
+		y: 0,
+		z: 0
+	}, ["Thigh"]),
+	...sidedLandmarks("ankle", "LowerLeg", {
+		x: 0,
+		y: -.4,
+		z: 0
+	}, ["Thigh", "LowerLeg"]),
+	...sidedLandmarks("sole", "LowerLeg", {
+		x: 0,
+		y: -.48,
+		z: .06
+	}, ["Thigh", "LowerLeg"]),
+	...sidedLandmarks("toe", "LowerLeg", {
+		x: 0,
+		y: -.445,
+		z: .18
+	}, ["Thigh", "LowerLeg"])
+];
+var JOINT_LANDMARK_MAP = Object.fromEntries(JOINT_LANDMARKS.map((landmark) => [landmark.id, landmark]));
+/**
+* Elbows and knees bend on one axis only. IK changes just their local X angle,
+* within this range, so they never bend backwards or twist.
+*/
+var HINGE_LIMITS = {
+	leftForearm: {
+		min: -160,
+		max: 0
+	},
+	rightForearm: {
+		min: -160,
+		max: 0
+	},
+	leftLowerLeg: {
+		min: 0,
+		max: 160
+	},
+	rightLowerLeg: {
+		min: 0,
+		max: 160
+	}
+};
+/** Per-axis limits (Euler degrees) IK applies to the torso and head so it cannot fold them unnaturally. */
+var BALL_LIMITS = {
+	chest: {
+		x: {
+			min: -40,
+			max: 90
+		},
+		y: {
+			min: -60,
+			max: 60
+		},
+		z: {
+			min: -45,
+			max: 45
+		}
+	},
+	neck: {
+		x: {
+			min: -50,
+			max: 60
+		},
+		y: {
+			min: -70,
+			max: 70
+		},
+		z: {
+			min: -40,
+			max: 40
+		}
+	},
+	head: {
+		x: {
+			min: -40,
+			max: 40
+		},
+		y: {
+			min: -50,
+			max: 50
+		},
+		z: {
+			min: -30,
+			max: 30
+		}
+	}
+};
+[
+	{
+		id: "light",
+		label: "明るいグレー",
+		value: "#c9c9c9"
+	},
+	{
+		id: "mid",
+		label: "グレー",
+		value: "#8e8e8e"
+	},
+	{
+		id: "dark",
+		label: "ダークグレー",
+		value: "#4f4f4f"
+	},
+	{
+		id: "white",
+		label: "白",
+		value: "#f0f0f0"
+	}
+][0].value;
+//#endregion
+//#region src/constants/cameraPresets.ts
+var v = (x, y, z) => ({
+	x,
+	y,
+	z
+});
+/** Camera presets. The character stands at the origin facing +Z. */
+var CAMERA_PRESETS = [
+	{
+		id: "front",
+		label: "正面",
+		position: v(0, 1, 3.4),
+		target: v(0, .95, 0)
+	},
+	{
+		id: "back",
+		label: "背面",
+		position: v(0, 1, -3.4),
+		target: v(0, .95, 0)
+	},
+	{
+		id: "left",
+		label: "左側面",
+		position: v(3.4, 1, 0),
+		target: v(0, .95, 0)
+	},
+	{
+		id: "right",
+		label: "右側面",
+		position: v(-3.4, 1, 0),
+		target: v(0, .95, 0)
+	},
+	{
+		id: "highAngle",
+		label: "ハイアングル",
+		position: v(1.6, 3.6, 2.6),
+		target: v(0, .85, 0)
+	},
+	{
+		id: "lowAngle",
+		label: "ローアングル",
+		position: v(1.3, .25, 3),
+		target: v(0, 1, 0)
+	},
+	{
+		id: "threeQuarter",
+		label: "斜め前",
+		position: v(1.95, 1.15, 2.78),
+		target: v(0, .95, 0)
+	}
+];
+Object.fromEntries(CAMERA_PRESETS.map((preset) => [preset.id, preset]));
+var FOV_RANGE = {
+	min: 15,
+	max: 120
+};
+var CAMERA_POSITION_RANGE = {
+	min: -10,
+	max: 10
+};
+var CAMERA_TARGET_RANGE = {
+	min: -4,
+	max: 4
+};
+//#endregion
+//#region src/utils/math.ts
+var DEG2RAD = Math.PI / 180;
+var RAD2DEG = 180 / Math.PI;
+function clamp(value, min, max) {
+	return Math.min(max, Math.max(min, value));
+}
+function round(value, decimals = 3) {
+	const factor = 10 ** decimals;
+	return Math.round(value * factor) / factor;
+}
+/** Normalizes an angle in degrees to the range [-180, 180). */
+function normalizeDegrees(degrees) {
+	return ((degrees + 180) % 360 + 360) % 360 - 180;
+}
+//#endregion
+//#region server/sceneSchema.ts
+/** Accepted ranges. They match the UI sliders so anything an agent sets can also be edited by hand. */
+var RANGES = {
+	angle: {
+		min: -360,
+		max: 360
+	},
+	rootOffset: {
+		min: -1.5,
+		max: 1.5
+	},
+	characterX: {
+		min: -3,
+		max: 3
+	},
+	characterY: {
+		min: -1,
+		max: 2
+	},
+	characterZ: {
+		min: -3,
+		max: 3
+	},
+	cameraPosition: CAMERA_POSITION_RANGE,
+	cameraTarget: CAMERA_TARGET_RANGE,
+	fov: FOV_RANGE
+};
+var between = (range) => z.number().min(range.min).max(range.max);
+var vec3 = (x, y = x, zRange = x) => z.strictObject({
+	x: between(x),
+	y: between(y),
+	z: between(zRange)
+});
+var angle = between(RANGES.angle).transform(normalizeDegrees);
+/** Missing axes mean 0, so `{ "x": -90 }` is enough to lift a thigh. */
+var rotation = z.strictObject({
+	x: angle.default(0),
+	y: angle.default(0),
+	z: angle.default(0)
+});
+var boneIds = BONE_IDS;
+var aspectRatioIds = ASPECT_RATIOS.map((option) => option.id);
+var sceneSchema = z.strictObject({
+	version: z.literal(1).optional().describe("Scene format version. Always 1."),
+	pose: z.strictObject({
+		mode: z.enum(["replace", "merge"]).optional().describe("'replace' (default): bones not listed are reset to 0. 'merge': bones not listed keep their current rotation."),
+		bones: z.partialRecord(z.enum(boneIds), rotation).optional().describe("Per-bone local Euler XYZ rotation in degrees. See get_pose_spec for axis conventions."),
+		rootOffset: vec3(RANGES.rootOffset).optional().describe("Offset of the hips in meters. y is adjusted by grounding unless ground is false."),
+		ground: z.boolean().optional().describe("Default true: after applying, raise or lower the hips so the lowest body point rests on the floor. Set false for jumps or other airborne poses.")
+	}).optional(),
+	character: z.strictObject({
+		yaw: between(RANGES.angle).transform(normalizeDegrees).optional().describe("Whole-body turn in degrees. 0 faces +Z."),
+		position: vec3(RANGES.characterX, RANGES.characterY, RANGES.characterZ).optional()
+	}).optional(),
+	camera: z.strictObject({
+		position: vec3(RANGES.cameraPosition).optional().describe("Camera position in meters."),
+		target: vec3(RANGES.cameraTarget).optional().describe("Point the camera looks at, in meters."),
+		fov: between(RANGES.fov).optional().describe("Vertical field of view in degrees.")
+	}).optional(),
+	aspectRatio: z.enum(aspectRatioIds).optional().describe("Output image aspect ratio.")
+});
+var renderViewsSchema = z.strictObject({
+	views: z.array(z.enum([
+		"current",
+		"front",
+		"back",
+		"left",
+		"right",
+		"top"
+	])).min(1).max(6).optional().describe("Views to render side by side. 'current' is the user's camera and composition; the others are framed on the character and follow its yaw. Default: current, front, left."),
+	size: z.number().int().min(256).max(768).optional().describe("Height of each view in pixels. Default 480.")
+});
+var JOINT_IDS = JOINT_LANDMARKS.map((landmark) => landmark.id);
+var jointPositionsSchema = z.strictObject({ pairs: z.array(z.tuple([z.enum(JOINT_IDS), z.enum(JOINT_IDS)])).max(20).optional().describe("Joint pairs to measure, e.g. [[\"rightElbow\",\"rightKnee\"],[\"rightPalm\",\"chin\"]]. Distances are returned in meters.") });
+var worldPoint = z.strictObject({
+	x: between({
+		min: -5,
+		max: 5
+	}),
+	y: between({
+		min: -5,
+		max: 5
+	}),
+	z: between({
+		min: -5,
+		max: 5
+	})
+});
+var reachSchema = z.strictObject({
+	goals: z.array(z.strictObject({
+		effector: z.enum(JOINT_IDS).describe("Landmark to move, e.g. \"rightElbow\" or \"rightPalm\"."),
+		target: z.union([z.enum(JOINT_IDS), worldPoint]).describe("Landmark name, or a world point in meters, to move the effector to."),
+		offset: z.strictObject({
+			x: between({
+				min: -1,
+				max: 1
+			}),
+			y: between({
+				min: -1,
+				max: 1
+			}),
+			z: between({
+				min: -1,
+				max: 1
+			})
+		}).optional().describe("World-space offset added to the target, e.g. {\"x\":0,\"y\":0.11,\"z\":0} to rest an elbow on top of a knee."),
+		chain: z.array(z.enum(boneIds)).min(1).max(6).optional().describe("Bones allowed to rotate, root side first. Default: the effector's usual chain, minus bones used by earlier goals.")
+	})).min(1).max(4).describe("Solved in order and re-checked on every pass, so list the goal that must hold most firmly first."),
+	ground: z.boolean().optional().describe("Default true: keep the body resting on the floor afterwards.")
+});
+/**
+* Parameters the internal /poseref/bridge endpoint accepts per method. The
+* stdio MCP process validates tool input already; the server checks again so
+* the endpoint never forwards anything the browser side does not expect.
+*/
+var bridgeParamSchemas = {
+	getScene: z.strictObject({}),
+	getJoints: z.strictObject({}),
+	setScene: sceneSchema,
+	renderViews: renderViewsSchema.required()
+};
+/** Bridge requests are small JSON documents; anything bigger is not ours. */
+var MAX_BODY_BYTES = 262144;
+function json(res, status, body, close = false) {
+	res.writeHead(status, {
+		"Content-Type": "application/json",
+		"Cache-Control": "no-store",
+		...close ? { Connection: "close" } : {}
+	});
+	res.end(JSON.stringify(body));
+}
+function readBody(req) {
+	return new Promise((resolve, reject) => {
+		const chunks = [];
+		let size = 0;
+		let tooLarge = false;
+		req.on("data", (chunk) => {
+			if (tooLarge) return;
+			size += chunk.length;
+			if (size > MAX_BODY_BYTES) {
+				tooLarge = true;
+				chunks.length = 0;
+				reject(Object.assign(/* @__PURE__ */ new Error("Request body too large"), { status: 413 }));
+				return;
+			}
+			chunks.push(chunk);
+		});
+		req.on("end", () => resolve(Buffer.concat(chunks).toString("utf8")));
+		req.on("error", reject);
+	});
+}
+/**
+* Endpoints for PoseRef's own stdio MCP processes, never for web pages:
+* - GET  /poseref/identify?nonce=… proves this is PoseRef (HMAC of the nonce with the per-user secret)
+* - POST /poseref/bridge            forwards one request to the browser tab (bearer secret required)
+* - POST /poseref/shutdown          stops the server (bearer secret required)
+* Returns false when the path is not an internal one.
+*/
+function createInternalHandler(options) {
+	return (req, res) => {
+		const url = new URL(req.url ?? "/", "http://localhost");
+		if (!url.pathname.startsWith("/poseref/")) return false;
+		if (req.headers.origin !== void 0) {
+			json(res, 403, { error: "Forbidden" });
+			return true;
+		}
+		if (url.pathname === `/poseref/identify` && req.method === "GET") {
+			const nonce = url.searchParams.get("nonce") ?? "";
+			if (!isValidNonce(nonce)) {
+				json(res, 400, { error: "Invalid nonce" });
+				return true;
+			}
+			json(res, 200, {
+				app: "poseref",
+				version: options.version,
+				tabs: options.bridge.connectedTabs,
+				proof: identityProof(options.secret, nonce)
+			});
+			return true;
+		}
+		if (req.method !== "POST" || !(url.pathname === `/poseref/bridge` || url.pathname === `/poseref/shutdown`)) {
+			json(res, 404, { error: "Not found" });
+			return true;
+		}
+		if (!bearerMatches(options.secret, req.headers.authorization)) {
+			json(res, 401, { error: "Unauthorized" });
+			return true;
+		}
+		if (url.pathname === `/poseref/shutdown`) {
+			if (!options.onShutdown) {
+				json(res, 409, { error: "This PoseRef server is managed by another process (e.g. npm run dev)." });
+				return true;
+			}
+			json(res, 200, { ok: true });
+			options.onShutdown();
+			return true;
+		}
+		if (!(req.headers["content-type"] ?? "").startsWith("application/json")) {
+			json(res, 415, { error: "Expected application/json" });
+			return true;
+		}
+		handleBridge(req, res, options.bridge);
+		return true;
+	};
+}
+async function handleBridge(req, res, bridge) {
+	let payload;
+	try {
+		payload = JSON.parse(await readBody(req));
+	} catch (error) {
+		const status = error.status ?? 400;
+		json(res, status, { error: status === 413 ? "Request body too large" : "Invalid request body" }, status === 413);
+		return;
+	}
+	const method = payload.method;
+	if (typeof method !== "string" || !Object.hasOwn(bridgeParamSchemas, method)) {
+		json(res, 400, { error: "Unknown method" });
+		return;
+	}
+	const parsed = bridgeParamSchemas[method].safeParse(payload.params ?? {});
+	if (!parsed.success) {
+		json(res, 400, { error: `Invalid params: ${parsed.error.message}` });
+		return;
+	}
+	try {
+		json(res, 200, {
+			ok: true,
+			result: await bridge.request(method, parsed.data)
+		});
+	} catch (error) {
+		const message = error instanceof Error ? error.message : String(error);
+		json(res, error instanceof NoBrowserError ? 503 : 200, {
+			ok: false,
+			error: message
+		});
+	}
+}
+//#endregion
+//#region src/utils/rotation.ts
+var scratchEuler$1 = new Euler(0, 0, 0, "XYZ");
+var scratchQuaternion = new Quaternion();
+/**
+* Every XYZ Euler triple has a second triple describing the same orientation:
+* (x, y, z) and (x + 180, 180 - y, z + 180). Which one `setFromQuaternion`
+* returns depends on the quaternion, so a continuous drag can suddenly switch
+* representation and make the rotation sliders jump even though the pose is
+* unchanged. Picking the triple closest to the previous value hides that.
+*/
+function alternativeEuler(value) {
+	return {
+		x: normalizeDegrees(value.x + 180),
+		y: normalizeDegrees(180 - value.y),
+		z: normalizeDegrees(value.z + 180)
+	};
+}
+function toQuaternion(value, target) {
+	scratchEuler$1.set(value.x * DEG2RAD, value.y * DEG2RAD, value.z * DEG2RAD, "XYZ");
+	return target.setFromEuler(scratchEuler$1);
+}
+/** Sum of the shortest-arc distances per axis, used to compare two triples. */
+function distanceTo(value, reference) {
+	return Math.abs(normalizeDegrees(value.x - reference.x)) + Math.abs(normalizeDegrees(value.y - reference.y)) + Math.abs(normalizeDegrees(value.z - reference.z));
+}
+function describesSameRotation(value, quaternion) {
+	const rebuilt = toQuaternion(value, scratchQuaternion);
+	return Math.abs(rebuilt.dot(quaternion)) > .999;
+}
+/**
+* Converts a quaternion to XYZ Euler angles in degrees, each within [-180, 180).
+* When `previous` is given, the equivalent triple closest to it is returned so
+* that values stay continuous across a drag.
+*/
+function eulerDegreesFromQuaternion(quaternion, previous) {
+	scratchEuler$1.setFromQuaternion(quaternion, "XYZ");
+	const candidate = {
+		x: normalizeDegrees(scratchEuler$1.x * RAD2DEG),
+		y: normalizeDegrees(scratchEuler$1.y * RAD2DEG),
+		z: normalizeDegrees(scratchEuler$1.z * RAD2DEG)
+	};
+	if (!previous) return candidate;
+	const alternative = alternativeEuler(candidate);
+	if (distanceTo(alternative, previous) >= distanceTo(candidate, previous)) return candidate;
+	return describesSameRotation(alternative, quaternion) ? alternative : candidate;
+}
+//#endregion
+//#region src/utils/ik.ts
+var MAX_PASSES = 60;
+var TOLERANCE = .003;
+/** Largest rotation a single CCD step may apply; keeps the solve from flipping limbs around. */
+var MAX_STEP = 40 * DEG2RAD;
+var scratchEuler = new Euler(0, 0, 0, "XYZ");
+var X_AXIS = new Vector3(1, 0, 0);
+var ONE = new Vector3(1, 1, 1);
+function eulerQuaternion(rotation) {
+	scratchEuler.set(rotation.x * DEG2RAD, rotation.y * DEG2RAD, rotation.z * DEG2RAD, "XYZ");
+	return new Quaternion().setFromEuler(scratchEuler);
+}
+/** World matrix of every bone, in the same order and with the same transforms as the rendered mannequin. */
+function forwardKinematics(frame) {
+	const character = new Matrix4().compose(new Vector3(frame.characterPosition.x, frame.characterPosition.y, frame.characterPosition.z), eulerQuaternion({
+		x: 0,
+		y: frame.characterYaw,
+		z: 0
+	}), ONE);
+	const worlds = /* @__PURE__ */ new Map();
+	for (const bone of BONES) {
+		const offset = bone.id === "hips" ? frame.rootOffset : {
+			x: 0,
+			y: 0,
+			z: 0
+		};
+		const local = new Matrix4().compose(new Vector3(bone.offset.x + offset.x, bone.offset.y + offset.y, bone.offset.z + offset.z), eulerQuaternion(frame.bones[bone.id]), ONE);
+		const parent = bone.parent ? worlds.get(bone.parent) : character;
+		worlds.set(bone.id, parent.clone().multiply(local));
+	}
+	return worlds;
+}
+function landmarkPosition(worlds, id) {
+	const landmark = JOINT_LANDMARK_MAP[id];
+	return new Vector3(landmark.offset.x, landmark.offset.y, landmark.offset.z).applyMatrix4(worlds.get(landmark.bone));
+}
+function isAncestorOrSelf(bone, of) {
+	for (let current = of; current; current = BONE_MAP[current].parent) if (current === bone) return true;
+	return false;
+}
+/** Returns an error message when the goal cannot be solved as given, otherwise null. */
+function checkGoal(goal, chain) {
+	const landmark = JOINT_LANDMARK_MAP[goal.effector];
+	if (!landmark) return `Unknown effector "${goal.effector}".`;
+	if (typeof goal.target === "string" && !JOINT_LANDMARK_MAP[goal.target]) return `Unknown target "${goal.target}".`;
+	if (chain.length === 0) return `${goal.effector} has no bones left to rotate; pass a chain explicitly.`;
+	const stray = chain.find((bone) => !isAncestorOrSelf(bone, landmark.bone));
+	if (stray) return `${stray} does not move ${goal.effector}; a chain may only contain ${landmark.bone} and its parents.`;
+	return null;
+}
+function targetPosition(worlds, goal) {
+	const base = typeof goal.target === "string" ? landmarkPosition(worlds, goal.target) : new Vector3(goal.target.x, goal.target.y, goal.target.z);
+	if (goal.offset) base.add(new Vector3(goal.offset.x, goal.offset.y, goal.offset.z));
+	return base;
+}
+function worldQuaternion(matrix) {
+	const position = new Vector3();
+	const quaternion = new Quaternion();
+	matrix.decompose(position, quaternion, new Vector3());
+	return quaternion;
+}
+function parentQuaternion(worlds, bone, frame) {
+	const parent = BONE_MAP[bone].parent;
+	return parent ? worldQuaternion(worlds.get(parent)) : eulerQuaternion({
+		x: 0,
+		y: frame.characterYaw,
+		z: 0
+	});
+}
+function clampBall(bone, rotation) {
+	const limits = BALL_LIMITS[bone];
+	if (!limits) return rotation;
+	return {
+		x: clamp(rotation.x, limits.x.min, limits.x.max),
+		y: clamp(rotation.y, limits.y.min, limits.y.max),
+		z: clamp(rotation.z, limits.z.min, limits.z.max)
+	};
+}
+/** One CCD step: turn `bone` so the effector swings toward the target. */
+function stepBone(frame, bone, goal) {
+	const worlds = forwardKinematics(frame);
+	const pivot = new Vector3().setFromMatrixPosition(worlds.get(bone));
+	const toEffector = landmarkPosition(worlds, goal.effector).sub(pivot);
+	const toTarget = targetPosition(worlds, goal).sub(pivot);
+	if (toEffector.lengthSq() < 1e-8 || toTarget.lengthSq() < 1e-8) return;
+	const current = frame.bones[bone];
+	const hinge = HINGE_LIMITS[bone];
+	if (hinge) {
+		const axis = X_AXIS.clone().applyQuaternion(parentQuaternion(worlds, bone, frame));
+		const from = toEffector.clone().sub(axis.clone().multiplyScalar(toEffector.dot(axis)));
+		const to = toTarget.clone().sub(axis.clone().multiplyScalar(toTarget.dot(axis)));
+		if (from.lengthSq() < 1e-8 || to.lengthSq() < 1e-8) return;
+		const limited = clamp(Math.atan2(axis.dot(from.clone().cross(to)), from.dot(to)), -MAX_STEP, MAX_STEP) * RAD2DEG;
+		frame.bones[bone] = {
+			...current,
+			x: clamp(current.x + limited, hinge.min, hinge.max)
+		};
+		return;
+	}
+	const delta = new Quaternion().setFromUnitVectors(toEffector.normalize(), toTarget.normalize());
+	const angle = 2 * Math.acos(clamp(delta.w, -1, 1));
+	if (angle > MAX_STEP) delta.slerp(new Quaternion(), 1 - MAX_STEP / angle);
+	const boneWorld = worldQuaternion(worlds.get(bone));
+	const local = parentQuaternion(worlds, bone, frame).invert().multiply(delta.multiply(boneWorld));
+	frame.bones[bone] = clampBall(bone, eulerDegreesFromQuaternion(local, current));
+}
+/** Rotates `bone` by a world-space rotation, keeping everything else fixed. */
+function rotateInWorld(frame, bone, delta) {
+	const worlds = forwardKinematics(frame);
+	const boneWorld = worldQuaternion(worlds.get(bone));
+	const local = parentQuaternion(worlds, bone, frame).invert().multiply(delta.clone().multiply(boneWorld));
+	frame.bones[bone] = clampBall(bone, eulerDegreesFromQuaternion(local, frame.bones[bone]));
+}
+/** Direction the elbow or knee should point when the limb starts out straight. */
+function defaultPole(worlds, upper, frame) {
+	const side = upper.startsWith("left") ? 1 : -1;
+	return (upper.endsWith("UpperArm") ? new Vector3(side * .6, -1, -.4) : new Vector3(side * .2, 0, 1)).normalize().applyQuaternion(parentQuaternion(worlds, upper, frame));
+}
+/**
+* Analytic two-bone step for upper arm + forearm or thigh + lower leg: bend the
+* hinge until the limb is exactly as long as the distance to the target, point
+* the limb at the target, then swivel it about that line so the elbow or knee
+* faces the pole. CCD alone gets stuck here because it never twists the upper
+* bone to line the hinge up with a target off to the side.
+*/
+function stepTwoBone(frame, upper, hinge, goal) {
+	const limits = HINGE_LIMITS[hinge];
+	let worlds = forwardKinematics(frame);
+	const shoulder = new Vector3().setFromMatrixPosition(worlds.get(upper));
+	const target = targetPosition(worlds, goal);
+	const wanted = target.distanceTo(shoulder);
+	const current = frame.bones[hinge];
+	const pole = Math.abs(current.x) > 15 ? new Vector3().setFromMatrixPosition(worlds.get(hinge)).sub(shoulder) : defaultPole(worlds, upper, frame);
+	const reachAt = (x) => {
+		frame.bones[hinge] = {
+			...current,
+			x
+		};
+		return landmarkPosition(forwardKinematics(frame), goal.effector).distanceTo(shoulder);
+	};
+	let bestX = current.x;
+	let bestMiss = Infinity;
+	for (let x = limits.min; x <= limits.max; x += 5) {
+		const miss = Math.abs(reachAt(x) - wanted);
+		if (miss < bestMiss) [bestX, bestMiss] = [x, miss];
+	}
+	for (let x = bestX - 5; x <= bestX + 5; x += .25) {
+		const clamped = clamp(x, limits.min, limits.max);
+		const miss = Math.abs(reachAt(clamped) - wanted);
+		if (miss < bestMiss) [bestX, bestMiss] = [clamped, miss];
+	}
+	frame.bones[hinge] = {
+		...current,
+		x: bestX
+	};
+	worlds = forwardKinematics(frame);
+	const toEffector = landmarkPosition(worlds, goal.effector).sub(shoulder).normalize();
+	const toTarget = target.clone().sub(shoulder);
+	if (toTarget.lengthSq() < 1e-8) return;
+	toTarget.normalize();
+	rotateInWorld(frame, upper, new Quaternion().setFromUnitVectors(toEffector, toTarget));
+	worlds = forwardKinematics(frame);
+	const elbow = new Vector3().setFromMatrixPosition(worlds.get(hinge)).sub(shoulder);
+	const along = (v) => v.clone().sub(toTarget.clone().multiplyScalar(v.dot(toTarget)));
+	const from = along(elbow);
+	const to = along(pole);
+	if (from.lengthSq() < 1e-8 || to.lengthSq() < 1e-8) return;
+	const swivel = Math.atan2(toTarget.dot(from.clone().cross(to)), from.dot(to));
+	rotateInWorld(frame, upper, new Quaternion().setFromAxisAngle(toTarget, swivel));
+}
+/**
+* Twists `upper` about its own length (the line from its pivot to the hinge)
+* so the hinge's bend plane swings toward the target. The hinge pivot lies on
+* that line, so an elbow or knee placed by an earlier goal stays where it is;
+* only the forearm or lower leg sweeps around. Without this a hinge-only chain
+* can bend but never aim sideways.
+*/
+function stepTwist(frame, upper, hinge, goal) {
+	const worlds = forwardKinematics(frame);
+	const pivot = new Vector3().setFromMatrixPosition(worlds.get(upper));
+	const joint = new Vector3().setFromMatrixPosition(worlds.get(hinge));
+	const axis = joint.clone().sub(pivot);
+	if (axis.lengthSq() < 1e-8) return;
+	axis.normalize();
+	const across = (point) => {
+		const offset = point.clone().sub(joint);
+		return offset.sub(axis.clone().multiplyScalar(offset.dot(axis)));
+	};
+	const from = across(landmarkPosition(worlds, goal.effector));
+	const to = across(targetPosition(worlds, goal));
+	if (from.lengthSq() < 1e-8 || to.lengthSq() < 1e-8) return;
+	const angle = clamp(Math.atan2(axis.dot(from.clone().cross(to)), from.dot(to)), -MAX_STEP, MAX_STEP);
+	rotateInWorld(frame, upper, new Quaternion().setFromAxisAngle(axis, angle));
+}
+/** Hinges in the chain whose parent bone is not in it: their parent may still twist (see stepTwist). */
+function twistableHinges(chain) {
+	return chain.filter((bone) => HINGE_LIMITS[bone] && !chain.includes(BONE_MAP[bone].parent)).map((hinge) => [BONE_MAP[hinge].parent, hinge]);
+}
+/** The [upper, hinge] pair a chain ends with, when the effector sits past the hinge. */
+function twoBonePair(chain, effector) {
+	if (chain.length < 2) return null;
+	const [upper, hinge] = chain.slice(-2);
+	if (!HINGE_LIMITS[hinge] || BONE_MAP[hinge].parent !== upper) return null;
+	const landmark = JOINT_LANDMARK_MAP[effector];
+	const pastHinge = landmark.bone !== hinge || landmark.offset.x !== 0 || landmark.offset.y !== 0 || landmark.offset.z !== 0;
+	return isAncestorOrSelf(hinge, landmark.bone) && pastHinge ? [upper, hinge] : null;
+}
+function goalError(frame, goal) {
+	const worlds = forwardKinematics(frame);
+	return landmarkPosition(worlds, goal.effector).distanceTo(targetPosition(worlds, goal));
+}
+/** Resolves each goal's chain: explicit, or the default chain minus bones earlier goals already use. */
+function resolveChains(goals) {
+	const claimed = /* @__PURE__ */ new Set();
+	return goals.map((goal) => {
+		const chain = goal.chain ?? (JOINT_LANDMARK_MAP[goal.effector]?.ikChain ?? []).filter((bone) => !claimed.has(bone));
+		for (const bone of chain) claimed.add(bone);
+		return chain;
+	});
+}
+/**
+* Cyclic coordinate descent over all goals. Goals are visited in order on every
+* pass, so an earlier goal is re-satisfied after a later one disturbs it.
+* Returns the new rotations and each goal's remaining error; check the errors,
+* because an out-of-reach target leaves the limb pointing at it but short.
+*/
+function solveIk(start, goals, chains) {
+	const frame = {
+		...start,
+		bones: structuredClone(start.bones)
+	};
+	const twists = chains.map(twistableHinges);
+	for (let pass = 0; pass < MAX_PASSES; pass++) {
+		goals.forEach((goal, index) => {
+			const pair = twoBonePair(chains[index], goal.effector);
+			const rest = pair ? chains[index].slice(0, -2) : chains[index];
+			if (pair) stepTwoBone(frame, pair[0], pair[1], goal);
+			for (const bone of [...rest].reverse()) stepBone(frame, bone, goal);
+			for (const [upper, hinge] of twists[index]) stepTwist(frame, upper, hinge, goal);
+		});
+		if (goals.every((goal) => goalError(frame, goal) < TOLERANCE)) break;
+	}
+	const changed = [.../* @__PURE__ */ new Set([...chains.flat(), ...twists.flat().map(([upper]) => upper)])];
+	for (const bone of changed) {
+		const r = frame.bones[bone];
+		frame.bones[bone] = {
+			x: round(r.x, 1),
+			y: round(r.y, 1),
+			z: round(r.z, 1)
+		};
+	}
+	return {
+		bones: frame.bones,
+		changed,
+		goals: goals.map((goal, index) => ({
+			effector: goal.effector,
+			chain: chains[index],
+			error: round(goalError(frame, goal))
+		}))
+	};
+}
+//#endregion
+//#region src/constants/posePresets.ts
+var r = (x, y, z) => ({
+	x,
+	y,
+	z
+});
+/**
+* Pose presets in degrees (Euler XYZ per bone).
+* Conventions: limbs hang along -Y at rest. For arms, negative X swings forward,
+* positive Z raises the left arm outward (negative Z for the right arm).
+* For legs, negative X lifts the thigh forward and positive X on the lower leg bends the knee.
+* Torso/head bones point +Y: positive X leans forward, positive Y turns to the left of the character.
+*/
+var POSE_PRESETS = [
+	{
+		id: "tPose",
+		label: "Tポーズ",
+		labelEn: "T-Pose",
+		group: "standing",
+		bones: {
+			leftUpperArm: r(0, 0, 90),
+			rightUpperArm: r(0, 0, -90)
+		}
+	},
+	{
+		id: "standing",
+		label: "立ち",
+		labelEn: "Standing",
+		group: "standing",
+		bones: {
+			leftUpperArm: r(-3, 0, 7),
+			rightUpperArm: r(-3, 0, -7),
+			leftForearm: r(-10, 0, 0),
+			rightForearm: r(-10, 0, 0),
+			leftThigh: r(0, 0, 3),
+			rightThigh: r(0, 0, -3)
+		}
+	},
+	{
+		id: "handsOnHips",
+		label: "腰に手",
+		labelEn: "Hands on Hips",
+		group: "standing",
+		bones: {
+			chest: r(-3, 0, 0),
+			leftUpperArm: r(15, 0, 45),
+			leftForearm: r(-67, 0, -66),
+			rightUpperArm: r(15, 0, -45),
+			rightForearm: r(-67, 0, 66),
+			leftThigh: r(0, 0, 5),
+			rightThigh: r(0, 0, -5)
+		}
+	},
+	{
+		id: "armsCrossed",
+		label: "腕組み",
+		labelEn: "Arms Crossed",
+		group: "standing",
+		bones: {
+			chest: r(3, 0, 0),
+			leftUpperArm: r(-62, 0, -8),
+			leftForearm: r(0, -12, -100),
+			rightUpperArm: r(-48, 0, 8),
+			rightForearm: r(0, 12, 100),
+			leftThigh: r(0, 0, 3),
+			rightThigh: r(0, 0, -3)
+		}
+	},
+	{
+		id: "handsBehindBack",
+		label: "後ろ手",
+		labelEn: "Hands Behind Back",
+		group: "standing",
+		bones: {
+			chest: r(-4, 0, 0),
+			leftUpperArm: r(25, 0, 12),
+			leftForearm: r(0, 0, -72),
+			rightUpperArm: r(28, 0, -12),
+			rightForearm: r(0, 0, 72),
+			leftThigh: r(0, 0, 3),
+			rightThigh: r(0, 0, -3)
+		}
+	},
+	{
+		id: "modelPose",
+		label: "モデル立ち",
+		labelEn: "Model Pose",
+		group: "standing",
+		bones: {
+			hips: r(0, 12, 5),
+			chest: r(0, -10, -6),
+			head: r(0, 6, 4),
+			rightThigh: r(0, 0, -5),
+			leftThigh: r(-10, 0, -3),
+			leftLowerLeg: r(15, 0, 0),
+			rightUpperArm: r(15, 0, -45),
+			rightForearm: r(-67, 0, 66),
+			leftUpperArm: r(-3, 0, 8),
+			leftForearm: r(-10, 0, 0)
+		},
+		rootOffset: r(0, -.02, 0)
+	},
+	{
+		id: "lookingBack",
+		label: "振り返り",
+		labelEn: "Looking Back",
+		group: "standing",
+		bones: {
+			hips: r(0, 8, 0),
+			chest: r(0, 35, 0),
+			neck: r(0, 25, 0),
+			head: r(-8, 45, 0),
+			leftUpperArm: r(8, 0, 6),
+			rightUpperArm: r(-6, 0, -8),
+			leftForearm: r(-15, 0, 0),
+			rightForearm: r(-12, 0, 0),
+			leftThigh: r(0, 0, 3),
+			rightThigh: r(0, 0, -3)
+		}
+	},
+	{
+		id: "peaceSign",
+		label: "ピース",
+		labelEn: "Peace Sign",
+		group: "gesture",
+		bones: {
+			head: r(0, 0, 8),
+			rightUpperArm: r(-25, 0, -50),
+			rightForearm: r(-140, 0, 0),
+			leftUpperArm: r(-3, 0, 8),
+			leftForearm: r(-12, 0, 0),
+			leftThigh: r(0, 0, 4),
+			rightThigh: r(0, 0, -4)
+		}
+	},
+	{
+		id: "waving",
+		label: "手を振る",
+		labelEn: "Waving",
+		group: "gesture",
+		bones: {
+			head: r(0, 0, 6),
+			rightUpperArm: r(-10, 0, -95),
+			rightForearm: r(0, 0, -75),
+			leftUpperArm: r(-3, 0, 8),
+			leftForearm: r(-10, 0, 0),
+			leftThigh: r(0, 0, 4),
+			rightThigh: r(0, 0, -4)
+		}
+	},
+	{
+		id: "pointing",
+		label: "指差し",
+		labelEn: "Pointing",
+		group: "gesture",
+		bones: {
+			chest: r(0, -6, 0),
+			head: r(0, -4, 0),
+			rightUpperArm: r(-92, 0, -8),
+			leftUpperArm: r(-3, 0, 8),
+			leftForearm: r(-10, 0, 0),
+			leftThigh: r(0, 0, 3),
+			rightThigh: r(0, 0, -3)
+		}
+	},
+	{
+		id: "thinking",
+		label: "考える",
+		labelEn: "Thinking",
+		group: "gesture",
+		bones: {
+			chest: r(3, 0, 0),
+			head: r(8, -8, 6),
+			rightUpperArm: r(-40, 0, -10),
+			rightForearm: r(-157, 0, 30),
+			leftUpperArm: r(-45, 0, -10),
+			leftForearm: r(0, -12, -100),
+			leftThigh: r(0, 0, 3),
+			rightThigh: r(0, 0, -3)
+		}
+	},
+	{
+		id: "salute",
+		label: "敬礼",
+		labelEn: "Salute",
+		group: "gesture",
+		bones: {
+			chest: r(-3, 0, 0),
+			rightUpperArm: r(-20, 0, -80),
+			rightForearm: r(-165, 0, -30),
+			leftUpperArm: r(0, 0, 3)
+		}
+	},
+	{
+		id: "cheering",
+		label: "バンザイ",
+		labelEn: "Cheering",
+		group: "gesture",
+		bones: {
+			chest: r(-5, 0, 0),
+			head: r(-10, 0, 0),
+			leftUpperArm: r(0, 0, 170),
+			rightUpperArm: r(0, 0, -170),
+			leftThigh: r(0, 0, 8),
+			rightThigh: r(0, 0, -8)
+		}
+	},
+	{
+		id: "handsBehindHead",
+		label: "後頭部に手",
+		labelEn: "Hands Behind Head",
+		group: "gesture",
+		bones: {
+			chest: r(-5, 0, 0),
+			head: r(-5, 0, 0),
+			leftUpperArm: r(20, 0, 110),
+			leftForearm: r(156, 0, 31),
+			rightUpperArm: r(20, 0, -110),
+			rightForearm: r(156, 0, -31),
+			leftThigh: r(0, 0, 5),
+			rightThigh: r(0, 0, -5)
+		}
+	},
+	{
+		id: "walking",
+		label: "歩く",
+		labelEn: "Walking",
+		group: "action",
+		bones: {
+			chest: r(3, 0, 0),
+			leftThigh: r(-25, 0, 1),
+			leftLowerLeg: r(15, 0, 0),
+			rightThigh: r(20, 0, -1),
+			rightLowerLeg: r(15, 0, 0),
+			rightUpperArm: r(-25, 0, -5),
+			rightForearm: r(-20, 0, 0),
+			leftUpperArm: r(20, 0, 5),
+			leftForearm: r(-15, 0, 0)
+		},
+		rootOffset: r(0, -.04, 0)
+	},
+	{
+		id: "running",
+		label: "走る",
+		labelEn: "Running",
+		group: "action",
+		bones: {
+			chest: r(15, 0, 0),
+			head: r(-10, 0, 0),
+			leftThigh: r(-55, 0, 2),
+			leftLowerLeg: r(85, 0, 0),
+			rightThigh: r(30, 0, -2),
+			rightLowerLeg: r(20, 0, 0),
+			rightUpperArm: r(-55, 0, -8),
+			rightForearm: r(-95, 0, 0),
+			leftUpperArm: r(40, 0, 8),
+			leftForearm: r(-85, 0, 0)
+		},
+		rootOffset: r(0, -.22, 0)
+	},
+	{
+		id: "jumping",
+		label: "ジャンプ",
+		labelEn: "Jumping",
+		group: "action",
+		bones: {
+			chest: r(-5, 0, 0),
+			head: r(-10, 0, 0),
+			leftThigh: r(-60, 0, 8),
+			rightThigh: r(-60, 0, -8),
+			leftLowerLeg: r(90, 0, 0),
+			rightLowerLeg: r(90, 0, 0),
+			leftUpperArm: r(0, 0, 135),
+			rightUpperArm: r(0, 0, -135)
+		},
+		rootOffset: r(0, .25, 0)
+	},
+	{
+		id: "fightingPose",
+		label: "構え",
+		labelEn: "Fighting Pose",
+		group: "action",
+		bones: {
+			hips: r(0, 30, 0),
+			chest: r(8, -12, 0),
+			head: r(5, -18, 0),
+			rightThigh: r(-20, 0, -14),
+			rightLowerLeg: r(30, 0, 0),
+			leftThigh: r(12, 0, 14),
+			leftLowerLeg: r(20, 0, 0),
+			rightUpperArm: r(-70, 0, 10),
+			rightForearm: r(-100, 0, 0),
+			leftUpperArm: r(-60, 0, -25),
+			leftForearm: r(-130, 0, 0)
+		},
+		rootOffset: r(0, -.05, 0)
+	},
+	{
+		id: "sitting",
+		label: "椅子に座る",
+		labelEn: "Sitting",
+		group: "sitting",
+		bones: {
+			chest: r(5, 0, 0),
+			leftThigh: r(-90, 0, 6),
+			rightThigh: r(-90, 0, -6),
+			leftLowerLeg: r(90, 0, 0),
+			rightLowerLeg: r(90, 0, 0),
+			leftUpperArm: r(-22, 0, 6),
+			rightUpperArm: r(-22, 0, -6),
+			leftForearm: r(-40, 0, 0),
+			rightForearm: r(-40, 0, 0)
+		},
+		rootOffset: r(0, -.4, 0)
+	},
+	{
+		id: "kneeHug",
+		label: "体育座り",
+		labelEn: "Knee Hug",
+		group: "sitting",
+		bones: {
+			chest: r(15, 0, 0),
+			head: r(5, 0, 0),
+			leftThigh: r(-150, 0, 4),
+			rightThigh: r(-150, 0, -4),
+			leftLowerLeg: r(150, 0, 0),
+			rightLowerLeg: r(150, 0, 0),
+			leftUpperArm: r(-70, 0, -5),
+			leftForearm: r(43, 0, -55),
+			rightUpperArm: r(-70, 0, 5),
+			rightForearm: r(43, 0, 55)
+		},
+		rootOffset: r(0, -.75, 0)
+	},
+	{
+		id: "kneeling",
+		label: "片膝立ち",
+		labelEn: "Kneeling",
+		group: "sitting",
+		bones: {
+			chest: r(8, 0, 0),
+			leftThigh: r(0, 0, 3),
+			leftLowerLeg: r(90, 0, 0),
+			rightThigh: r(-90, 0, -5),
+			rightLowerLeg: r(90, 0, 0),
+			rightUpperArm: r(-40, 0, -5),
+			rightForearm: r(-50, 0, 0),
+			leftUpperArm: r(-5, 0, 8),
+			leftForearm: r(-15, 0, 0)
+		},
+		rootOffset: r(0, -.41, 0)
+	},
+	{
+		id: "seiza",
+		label: "正座",
+		labelEn: "Seiza",
+		group: "sitting",
+		bones: {
+			chest: r(2, 0, 0),
+			leftThigh: r(-55, 0, 6),
+			rightThigh: r(-55, 0, -6),
+			leftLowerLeg: r(145, 0, 0),
+			rightLowerLeg: r(145, 0, 0),
+			leftUpperArm: r(-25, 0, 5),
+			rightUpperArm: r(-25, 0, -5),
+			leftForearm: r(-30, 0, 0),
+			rightForearm: r(-30, 0, 0)
+		},
+		rootOffset: r(0, -.58, 0)
+	},
+	{
+		id: "crouching",
+		label: "しゃがむ",
+		labelEn: "Crouching",
+		group: "sitting",
+		bones: {
+			chest: r(25, 0, 0),
+			head: r(-15, 0, 0),
+			leftThigh: r(-110, 0, 15),
+			rightThigh: r(-110, 0, -15),
+			leftLowerLeg: r(130, 0, 0),
+			rightLowerLeg: r(130, 0, 0),
+			leftUpperArm: r(-60, 0, 10),
+			rightUpperArm: r(-60, 0, -10),
+			leftForearm: r(-40, 0, 0),
+			rightForearm: r(-40, 0, 0)
+		},
+		rootOffset: r(0, -.56, 0)
+	},
+	{
+		id: "lyingDown",
+		label: "仰向け",
+		labelEn: "Lying Down",
+		group: "sitting",
+		bones: {
+			hips: r(-90, 0, 0),
+			leftUpperArm: r(0, 0, 15),
+			rightUpperArm: r(0, 0, -15),
+			leftThigh: r(0, 0, 4),
+			rightThigh: r(-40, 0, -4),
+			rightLowerLeg: r(70, 0, 0)
+		},
+		rootOffset: r(0, -.82, 0)
+	}
+];
+var POSE_PRESET_MAP = Object.fromEntries(POSE_PRESETS.map((preset) => [preset.id, preset]));
+//#endregion
+//#region server/poseSpec.ts
+/** Presets quoted in full as worked examples. Chosen to cover arms, sitting and lying. */
+var EXAMPLE_PRESETS = [
+	"standing",
+	"handsOnHips",
+	"pointing",
+	"sitting",
+	"kneeling",
+	"lyingDown"
+];
+var fmt = (value) => String(Math.round(value * 1e3) / 1e3);
+var vec = (v) => `(${fmt(v.x)}, ${fmt(v.y)}, ${fmt(v.z)})`;
+var range = (r) => `${r.min}..${r.max}`;
+function boneTable() {
+	return [
+		"| id | parent | pivot offset from parent pivot (m) | Japanese name |",
+		"|---|---|---|---|",
+		...BONES.map((bone) => `| ${bone.id} | ${bone.parent ?? "(root)"} | ${vec(bone.offset)} | ${bone.label} |`)
+	].join("\n");
+}
+function presetExamples() {
+	return EXAMPLE_PRESETS.map((id) => {
+		const preset = POSE_PRESET_MAP[id];
+		const pose = {
+			bones: preset.bones,
+			...preset.rootOffset ? { rootOffset: preset.rootOffset } : {}
+		};
+		return `${preset.labelEn} (${preset.label}):\n\`${JSON.stringify(pose)}\``;
+	}).join("\n\n");
+}
+function cameraTable() {
+	return [
+		"| preset | position | target |",
+		"|---|---|---|",
+		...CAMERA_PRESETS.map((preset) => `| ${preset.id} (${preset.label}) | ${vec(preset.position)} | ${vec(preset.target)} |`)
+	].join("\n");
+}
+/**
+* Pose authoring guide handed to AI agents by the `get_pose_spec` tool. Bone
+* layout, examples, cameras and ranges are read from the app's own constants so
+* the guide cannot drift from the code; the axis conventions are prose.
+*/
+function buildPoseSpec() {
+	return `# PoseRef pose authoring guide
+
+PoseRef poses a featureless mannequin and frames it with a camera to make reference images for image AIs.
+You edit the scene with \`set_scene\` and check the result with \`render_views\`.
+
+## Workflow
+1. \`get_scene\` if you need the current state (for small edits use pose.mode "merge").
+2. \`set_scene\` with pose, and camera if the request mentions an angle or composition.
+3. \`render_views\` (current + front + left by default) and compare the picture with the request.
+4. For contact (hand on hip, elbow on knee, hands on the floor), place it with \`reach\` (see "Contact with reach")
+   and confirm with \`get_joint_positions\`; pictures are easy to misjudge. Feet-on-floor is handled by
+   set_scene's automatic grounding.
+5. Fix what is wrong and render again. Two or three rounds are usually enough: the user fine-tunes by hand afterwards.
+If a combined pose + camera change keeps failing, settle the pose first, then the camera.
+
+## World and character axes
+- The character stands at the origin facing +Z. +X is the CHARACTER'S LEFT, +Y is up. Units are meters.
+- Seen from a front camera (+Z), the character's left side appears on the RIGHT of the image.
+- \`character.yaw\` turns the whole body around Y; +90 makes it face +X.
+
+## Bones
+Rotations are local Euler angles in degrees, order XYZ (three.js: Z is applied first, then Y, then X),
+relative to the parent bone. A parent's rotation carries all of its children.
+Standing height: hips pivot ${fmt(HIPS_BASE_Y)} m above the floor, top of head about 1.72 m.
+The hand extends about 0.18 m past the wrist; the sole is about 0.48 m below the knee pivot.
+
+${boneTable()}
+
+## Where a hanging limb points (upper arm, forearm, hand, thigh, lower leg)
+At rest these point down (-Y). With rotation (x, y = 0, z) a limb points at
+\`dir = ( sin z, -cos z * cos x, -cos z * sin x )\` in its parent's space
+(+X = character's left, +Y = up, +Z = forward).
+- Arms: x < 0 swings the arm forward and up, x > 0 swings it back.
+  Left arm z > 0 raises it sideways; the RIGHT arm uses z < 0 (mirrored).
+  Straight overhead: left z = 170..180 (right z = -170..-180), or x = -170..-180.
+- Elbow: forearm x < 0 folds the forearm forward relative to the upper arm; -90 is a right angle.
+- Legs: thigh x < 0 lifts the leg forward (-90 = horizontal, as when sitting), x > 0 moves it behind.
+  Left thigh z > 0 spreads it outward; the right thigh uses z < 0.
+- Knee: lower leg x > 0 folds the shin backward; 90 is a right angle.
+- y on a limb only twists it around its own length.
+
+## Torso, neck and head (they point up)
+- x > 0 bends forward, x < 0 leans back.
+- y > 0 turns toward the character's LEFT.
+- z > 0 tilts sideways toward the character's RIGHT (-X).
+- hips rotate the whole body; hips x = -90 lays it on its back.
+
+## Common mistakes
+- Bending the chest forward also swings the arms backward, because they hang from the chest.
+  When the chest leans by +a degrees, subtract about a from the upper arms' x to keep them pointing the same way in the world.
+- Left and right use opposite z signs for arms and legs. Check the rendered front view: the character's
+  left hand is on the image's right.
+- Poses where body parts touch (hand on chin, elbow on knee) rarely land on the first try. Measure with
+  \`get_joint_positions\`: limb radii are about upper arm 0.05, forearm 0.043, thigh 0.068, shin 0.052 m and the
+  hand is 0.02-0.04 m thick, so an elbow resting on a knee is ~0.11 m from it and a palm on the chin is ~0.03-0.06 m.
+
+## Composition and readability
+The picture is a reference for an image AI, so the pose must read from its silhouette in the 'current' view.
+- Decide first where the character acts toward (a target, a direction of travel, something it looks at), then
+  place that direction across the picture rather than straight at or away from the camera, so the key limbs are
+  seen from the side instead of foreshortened.
+- Actions aimed at a target are done side-on: drawing a bow, aiming a rifle, throwing, swinging a bat, club or
+  racket. The lead side (for a right-handed person the left arm and left shoulder) faces the target, the chest
+  faces 90 degrees away from it, and the head turns toward the target. Turn the character with \`character.yaw\`
+  and keep the target direction across the frame.
+- Read camera words in the character's own frame: "from the front" means the camera sees the chest and face side
+  of the body, "from the side" sees a shoulder, "from behind" sees the back. For a side-on action seen from the
+  front, the target is therefore off to one side of the picture (for a right-handed person, on the character's
+  left, which is the image's right), not behind the camera.
+- Never square the body or the head to the camera just to show the face. A head turned toward the target, even
+  in profile, is part of the stance and reads better than a face looking into the lens.
+- In render_views, check that the arms and legs that carry the action do not overlap the torso or each other and
+  do not point at the camera. If they do, turn the character (often 15-30 degrees of yaw is enough) or move the
+  camera before fine-tuning angles. Do not finish with a readability problem you have noticed; fix it first.
+
+## Contact with reach (inverse kinematics)
+\`reach\` moves a landmark (effector) onto another landmark or a world point by rotating a chain of bones, so you
+do not have to work out the angles. Elbows and knees only bend the natural way; chest, neck and head stay within
+natural limits.
+- Default chains: elbow -> upper arm; wrist, palm, fingertips -> upper arm + forearm; knee -> thigh;
+  ankle, sole, toe -> thigh + lower leg; chin, nose, head -> neck + head; neckBase -> chest.
+- When a chain has an elbow or knee but not the bone above it (e.g. \`["rightForearm"]\` after an earlier goal
+  used the upper arm), the upper arm or thigh may still twist about its own length to aim the bend. That twist
+  keeps the elbow or knee where the earlier goal put it.
+- Goals are solved in order and re-checked on every pass. Bones used by an earlier goal are left out of later
+  goals' default chains, so list the contact that must hold most firmly first.
+- \`offset\` is added to the target in world space. Joint landmarks sit inside the limbs, so leave the limb radii
+  between them: an elbow resting on top of a knee is
+  \`{"effector":"rightElbow","target":"rightKnee","offset":{"x":0,"y":0.11,"z":0}}\`.
+- If a goal is reported NOT reached, the body is too far away for that chain. Change the rough pose, add a parent
+  bone to its chain (e.g. \`["chest","rightUpperArm"]\`), or add a second goal that moves the other body part
+  toward the first.
+- Two goals that only point at each other can meet anywhere. Anchor one to a place: hands together in front of the
+  chest is rightPalm -> a world point such as \`{"x":0,"y":1.25,"z":0.3}\`, then leftPalm -> rightPalm.
+- Straight limbs bend with the elbow down and slightly out and back, and the knee forward; an already bent limb
+  keeps its bend direction, so pre-bend it in the rough pose if you want another direction.
+- Hand on hip: \`{"goals":[{"effector":"leftPalm","target":"pelvis","offset":{"x":0.17,"y":0.02,"z":0}}]}\`
+  (offsets are in world space; rotate them when the character is turned).
+
+## Grounding (pose.rootOffset)
+\`set_scene\` grounds the body for you: after applying a pose it raises or lowers the hips so the lowest body
+point (sole, knee, buttocks or back) rests on the floor, and reports how far it moved them. You only need a
+rough rootOffset.y. For a chair pose the feet end up on the floor and the body sits in the air, because there is
+no chair. For jumps or other airborne poses pass \`pose.ground: false\` and set rootOffset.y yourself (a mid-jump
+preset uses +0.25).
+
+## Camera
+\`camera.position\` and \`camera.target\` are in meters, \`camera.fov\` is the vertical field of view in degrees
+(default 45). High angle: raise position.y to 3..4. Low angle: position.y 0.2..0.4 with target.y about 1.0.
+A lower fov from farther away flattens perspective.
+
+${cameraTable()}
+
+Aspect ratios: ${ASPECT_RATIOS.map((option) => option.id).join(", ")}.
+
+## Accepted ranges
+Bone angles ${range(RANGES.angle)} (normalized to -180..180), rootOffset ${range(RANGES.rootOffset)},
+character position x ${range(RANGES.characterX)} / y ${range(RANGES.characterY)} / z ${range(RANGES.characterZ)},
+camera position ${range(RANGES.cameraPosition)}, camera target ${range(RANGES.cameraTarget)}, fov ${range(RANGES.fov)}.
+
+## Examples (pose.bones and rootOffset of built-in presets)
+${presetExamples()}
+`;
+}
+//#endregion
+//#region server/version.ts
+/**
+* The folder holding PoseRef's package.json, found by walking up from this
+* file. That works from server/*.ts (development), dist-server/cli.js (the
+* published build, including inside npx's cache) and Vite's bundled config in
+* node_modules/.vite-temp alike. Built with path functions rather than
+* `new URL(..., import.meta.url)`, which Vite would rewrite into an asset.
+*/
+function findPackageRoot() {
+	let dir = dirname(fileURLToPath(import.meta.url));
+	for (let depth = 0; depth < 6; depth++) {
+		const manifest = join(dir, "package.json");
+		if (existsSync(manifest) && JSON.parse(readFileSync(manifest, "utf8")).name === "poseref") return dir;
+		dir = dirname(dir);
+	}
+	throw new Error("Could not find the PoseRef package.json.");
+}
+var PACKAGE_ROOT = findPackageRoot();
+var POSEREF_VERSION = JSON.parse(readFileSync(join(PACKAGE_ROOT, "package.json"), "utf8")).version;
+//#endregion
+//#region server/mcp.ts
+var DEFAULT_VIEWS = [
+	"current",
+	"front",
+	"left"
+];
+var DEFAULT_VIEW_SIZE = 480;
+/** A contact within 2 cm reads as touching in the render. */
+var REACHED_WITHIN = .02;
+var INSTRUCTIONS = `PoseRef controls a posable mannequin and camera in the user's browser to build pose and composition reference images.
+Call get_pose_spec once before your first set_scene: it explains the bone axes and sign conventions, which are easy to get wrong.
+Before posing, decide which way the character acts (a target, a direction) and keep that direction across the picture so the action reads in silhouette; aiming, throwing and swinging are done side-on (see the spec's "Composition and readability").
+Then loop: set_scene -> render_views -> compare with the request and check the silhouette from the 'current' view -> adjust. When the request has body parts touching (hand on hip, elbow on knee, hands together), set the rough pose first and then place the contacts with reach (inverse kinematics) instead of guessing angles; confirm with get_joint_positions and only report contact the numbers show. set_scene puts the body on the floor automatically. Stop after two or three rounds when the pose is roughly right; the user fine-tunes by hand and can undo your changes in the app.`;
+function text(value) {
+	return { content: [{
+		type: "text",
+		text: value
+	}] };
+}
+/** One-line JSON without zero rotations; bones left out are 0, matching set_scene's 'replace' mode. */
+function compactScene(scene) {
+	const bones = Object.fromEntries(Object.entries(scene.pose?.bones ?? {}).filter(([, r]) => r && (r.x !== 0 || r.y !== 0 || r.z !== 0)));
+	return JSON.stringify({
+		...scene,
+		pose: {
+			...scene.pose,
+			bones
+		}
+	});
+}
+function failure(error) {
+	return {
+		content: [{
+			type: "text",
+			text: error instanceof Error ? error.message : String(error)
+		}],
+		isError: true
+	};
+}
+/**
+* Saves the review image to a file as well. Clients that cannot show MCP image
+* content to the model (some Codex versions) can open the file instead.
+*/
+async function saveRender(pngBase64) {
+	const dir = rendersDir();
+	const path = join(dir, `review-${(/* @__PURE__ */ new Date()).toISOString().replace(/[:.]/g, "-")}.png`);
+	await writeFile(path, Buffer.from(pngBase64, "base64"));
+	const files = (await readdir(dir)).filter((name) => name.endsWith(".png")).sort();
+	await Promise.all(files.slice(0, -20).map((name) => rm(join(dir, name), { force: true })));
+	return path;
+}
+/** The PoseRef tools, working through any bridge: in-process for HTTP, remote for stdio. */
+function createPoseRefMcpServer(bridge) {
+	const server = new McpServer({
+		name: "poseref",
+		version: POSEREF_VERSION
+	}, { instructions: INSTRUCTIONS });
+	server.registerTool("get_pose_spec", {
+		title: "Get pose authoring guide",
+		description: "Returns the guide to PoseRef bones, axis conventions, grounding, camera and example poses. Read it before the first set_scene.",
+		annotations: { readOnlyHint: true }
+	}, async () => text(buildPoseSpec()));
+	server.registerTool("get_scene", {
+		title: "Get current scene",
+		description: "Returns the current pose, character transform, camera and aspect ratio from the open PoseRef tab as JSON. Bones not listed have zero rotation.",
+		annotations: { readOnlyHint: true }
+	}, async () => {
+		try {
+			return text(compactScene(await bridge.request("getScene", {})));
+		} catch (error) {
+			return failure(error);
+		}
+	});
+	server.registerTool("set_scene", {
+		title: "Set pose and camera",
+		description: "Applies a pose, character transform, camera and/or aspect ratio to the open PoseRef tab in one undoable step. Omitted sections are left unchanged. When a pose is given, the hips are moved so the body rests on the floor (turn off with pose.ground = false). Returns the resulting scene. Follow up with render_views to check the result.",
+		inputSchema: sceneSchema
+	}, async (scene) => {
+		try {
+			const { scene: applied, groundShift } = await bridge.request("setScene", {
+				version: 1,
+				...scene
+			});
+			return text(`Applied.${groundShift === null ? "" : groundShift === 0 ? " Already resting on the floor." : ` Grounded: hips moved ${groundShift > 0 ? "up" : "down"} by ${Math.abs(groundShift)} m so the lowest body point rests on the floor.`} Current scene (bones not listed are 0): ${compactScene(applied)}`);
+		} catch (error) {
+			return failure(error);
+		}
+	});
+	server.registerTool("render_views", {
+		title: "Render review views",
+		description: "Renders the scene from several views side by side in one labeled PNG so you can check the pose. 'current' shows the user's camera and composition. The image is also saved to a file whose path is returned.",
+		inputSchema: renderViewsSchema,
+		annotations: { readOnlyHint: true }
+	}, async ({ views, size }) => {
+		try {
+			const result = await bridge.request("renderViews", {
+				views: views ?? [...DEFAULT_VIEWS],
+				size: size ?? DEFAULT_VIEW_SIZE
+			});
+			const path = await saveRender(result.pngBase64);
+			return { content: [{
+				type: "image",
+				data: result.pngBase64,
+				mimeType: "image/png"
+			}, {
+				type: "text",
+				text: `Rendered ${result.width}x${result.height} px. Saved to ${path}`
+			}] };
+		} catch (error) {
+			return failure(error);
+		}
+	});
+	server.registerTool("get_joint_positions", {
+		title: "Get joint positions",
+		description: `Returns world positions in meters of joint landmarks (${JOINT_IDS.join(", ")}), the height of the lowest body point (lowestY, 0 = on the floor), and distances for the requested pairs. Use it to check contact instead of judging from the picture: joint landmarks sit inside the limbs, so two limbs touch when their distance is about the sum of the limb radii (elbow resting on knee ~0.11 m); chin and nose are on the head surface, so a palm touches the chin at ~0.03-0.06 m.`,
+		inputSchema: jointPositionsSchema,
+		annotations: { readOnlyHint: true }
+	}, async ({ pairs }) => {
+		try {
+			const report = await bridge.request("getJoints", {});
+			const distances = (pairs ?? []).map(([a, b]) => {
+				const p = report.joints[a];
+				const q = report.joints[b];
+				const d = p && q ? Math.hypot(p.x - q.x, p.y - q.y, p.z - q.z) : NaN;
+				return {
+					from: a,
+					to: b,
+					distance: Math.round(d * 1e3) / 1e3
+				};
+			});
+			return text(JSON.stringify({
+				lowestY: report.lowestY,
+				distances,
+				joints: report.joints
+			}));
+		} catch (error) {
+			return failure(error);
+		}
+	});
+	server.registerTool("reach", {
+		title: "Move joints to targets (IK)",
+		description: "Inverse kinematics: rotates bones so a landmark (effector) moves onto another landmark or a world point, e.g. an elbow onto a knee or a palm under the chin. Elbows and knees only bend the natural way and the torso and head stay within natural limits. Only the chain bones change, except that the upper arm or thigh above a chained elbow or knee may twist about its own length, which keeps that joint in place; the result is one undoable step. Set the rough pose with set_scene first, then use reach for contacts, then render_views to check.",
+		inputSchema: reachSchema
+	}, async ({ goals, ground }) => {
+		try {
+			const scene = await bridge.request("getScene", {});
+			const frame = {
+				bones: scene.pose.bones,
+				rootOffset: scene.pose.rootOffset,
+				characterPosition: scene.character.position,
+				characterYaw: scene.character.yaw
+			};
+			const chains = resolveChains(goals);
+			for (const [index, goal] of goals.entries()) {
+				const problem = checkGoal(goal, chains[index]);
+				if (problem) return failure(new Error(problem));
+			}
+			const result = solveIk(frame, goals, chains);
+			const bones = Object.fromEntries(result.changed.map((bone) => [bone, result.bones[bone]]));
+			const { groundShift } = await bridge.request("setScene", {
+				version: 1,
+				pose: {
+					mode: "merge",
+					bones,
+					ground
+				}
+			});
+			const lines = result.goals.map((goal) => `- ${goal.effector}: ${goal.error <= REACHED_WITHIN ? "reached" : "NOT reached"}, ${goal.error} m from the target (rotated ${goal.chain.join(", ")})`);
+			const advice = result.goals.some((goal) => goal.error > REACHED_WITHIN) ? "\nA target out of reach leaves the limb pointing at it but short. Move the body closer first (lean the chest, bend the legs), add a parent bone such as chest to that goal's chain, or add a goal that moves the other body part toward this one." : "";
+			const grounding = groundShift ? `\nGrounded: hips moved ${groundShift > 0 ? "up" : "down"} by ${Math.abs(groundShift)} m.` : "";
+			return text(`${lines.join("\n")}${advice}${grounding}\nNew rotations: ${JSON.stringify(bones)}`);
+		} catch (error) {
+			return failure(error);
+		}
+	});
+	return server;
+}
+/** Stateless Streamable HTTP handler: every request gets a fresh McpServer bound to the shared bridge. */
+function createPoseRefMcpHandler(bridge) {
+	return createMcpHandler(() => createPoseRefMcpServer(bridge));
+}
+//#endregion
+//#region server/app.ts
+var MCP_PATH = "/mcp";
+/** Loopback only: the server drives the user's browser tab and must not be reachable from the network. */
+var HOST = "127.0.0.1";
+var CONTENT_TYPES = {
+	".html": "text/html; charset=utf-8",
+	".js": "text/javascript; charset=utf-8",
+	".css": "text/css; charset=utf-8",
+	".json": "application/json",
+	".svg": "image/svg+xml",
+	".png": "image/png",
+	".ico": "image/x-icon",
+	".woff2": "font/woff2"
+};
+async function serveStatic(root, req, res) {
+	const pathname = decodeURIComponent(new URL(req.url ?? "/", "http://localhost").pathname);
+	let file = normalize(join(root, pathname));
+	if (file !== root && !file.startsWith(root + sep)) {
+		res.writeHead(403).end();
+		return;
+	}
+	const info = await stat(file).catch(() => null);
+	if (!info || info.isDirectory()) file = join(root, "index.html");
+	const type = CONTENT_TYPES[extname(file)] ?? "application/octet-stream";
+	const isHtml = type.startsWith("text/html");
+	res.writeHead(200, {
+		"Content-Type": type,
+		"Cache-Control": isHtml ? "no-cache" : "public, max-age=31536000, immutable"
+	});
+	createReadStream(file).pipe(res);
+}
+/**
+* One local process that serves the PoseRef app, the WebSocket the app connects
+* back on (`/ws`), and two ways in for AI agents: the Streamable HTTP MCP
+* endpoint (`/mcp`) for agents registered by URL, and the internal endpoints
+* (`/poseref/*`) that the stdio MCP processes started by `poseref mcp` use.
+*/
+function createPoseRefServer(options) {
+	const appUrl = `http://${HOST}:${options.port}`;
+	const allowedOrigins = /* @__PURE__ */ new Set([
+		appUrl,
+		`http://localhost:${options.port}`,
+		...options.extraOrigins ?? []
+	]);
+	const bridge = new BrowserBridge(appUrl);
+	const mcp = toNodeHandler(createPoseRefMcpHandler(bridge));
+	const staticRoot = options.staticDir ? resolve(options.staticDir) : null;
+	const validateHost = localhostHostValidation();
+	const validateOrigin = localhostOriginValidation();
+	const internal = createInternalHandler({
+		secret: options.secret,
+		version: options.version,
+		bridge,
+		onShutdown: options.onShutdown
+	});
+	const server = createServer((req, res) => {
+		if (!validateHost(req, res)) return;
+		if (internal(req, res)) return;
+		if (new URL(req.url ?? "/", "http://localhost").pathname === "/mcp") {
+			if (!validateOrigin(req, res)) return;
+			mcp(req, res);
+			return;
+		}
+		if (staticRoot) {
+			serveStatic(staticRoot, req, res).catch(() => {
+				if (!res.headersSent) res.writeHead(500);
+				res.end();
+			});
+			return;
+		}
+		res.writeHead(404, { "Content-Type": "text/plain; charset=utf-8" }).end("PoseRef MCP server. The app is served by Vite.");
+	});
+	const sockets = new WebSocketServer({ noServer: true });
+	server.on("upgrade", (req, socket, head) => {
+		if (new URL(req.url ?? "/", "http://localhost").pathname !== "/ws" || !allowedOrigins.has(req.headers.origin ?? "")) {
+			socket.end("HTTP/1.1 403 Forbidden\r\n\r\n");
+			return;
+		}
+		sockets.handleUpgrade(req, socket, head, (ws) => bridge.attach(ws));
+	});
+	return {
+		appUrl,
+		mcpUrl: `${appUrl}${MCP_PATH}`,
+		/** The port actually bound; differs from options.port only when that was 0 (tests). */
+		port() {
+			return server.address().port;
+		},
+		listen() {
+			return new Promise((resolveListen, rejectListen) => {
+				server.once("error", rejectListen);
+				server.listen(options.port, HOST, () => {
+					server.off("error", rejectListen);
+					resolveListen();
+				});
+			});
+		},
+		close() {
+			bridge.closeAll();
+			sockets.close();
+			return new Promise((resolveClose) => server.close(() => resolveClose()));
+		}
+	};
+}
+//#endregion
+//#region server/browser.ts
+/**
+* Opens the PoseRef page in the default browser. The URL is always one PoseRef
+* built itself (http://127.0.0.1:<port>), and no shell is involved, so nothing
+* from outside can reach the command line.
+*/
+function openBrowser(url, log) {
+	if (!/^http:\/\/127\.0\.0\.1:\d+\/?$/.test(url)) throw new Error(`Refusing to open unexpected URL: ${url}`);
+	const [command, args] = process.platform === "win32" ? ["explorer.exe", [url]] : process.platform === "darwin" ? ["open", [url]] : ["xdg-open", [url]];
+	const child = spawn(command, args, {
+		detached: true,
+		stdio: "ignore",
+		windowsHide: true
+	});
+	child.on("error", () => log(`ブラウザで ${url} を開いてください。`));
+	child.unref();
+}
+//#endregion
+//#region server/port.ts
+/** Fixed default so the MCP URL registered with agents stays valid across restarts. */
+var DEFAULT_PORT = 47173;
+function resolvePort() {
+	const value = Number(process.env.POSEREF_PORT);
+	return Number.isInteger(value) && value > 0 && value < 65536 ? value : DEFAULT_PORT;
+}
+//#endregion
+//#region server/remote.ts
+var START_TIMEOUT_MS = 15e3;
+var TAB_WAIT_MS = 2e4;
+var POLL_MS = 300;
+var REQUEST_TIMEOUT_MS = 3e4;
+var sleep = (ms) => new Promise((resolve) => setTimeout(resolve, ms));
+/**
+* The bridge used by `poseref mcp` (the stdio MCP server an agent starts). The
+* tools run in this process; only browser requests go to the long-running
+* PoseRef server. Nothing is started until a tool actually needs the browser,
+* because agents launch their MCP servers at the start of every session.
+*
+* Before any data is sent, the listener on the port must prove it holds the
+* per-user secret; a different program on that port is reported, never trusted.
+*/
+var RemoteBridge = class {
+	options;
+	baseUrl;
+	ready = null;
+	browserOpened = false;
+	constructor(options) {
+		this.options = options;
+		this.baseUrl = `http://127.0.0.1:${options.port}`;
+	}
+	async request(method, params) {
+		try {
+			await this.ensureReady();
+			return await this.call(method, params);
+		} catch (error) {
+			if (!(error instanceof TransportError)) throw error;
+			this.ready = null;
+			await this.ensureReady();
+			return await this.call(method, params);
+		}
+	}
+	ensureReady() {
+		this.ready ??= this.prepare().catch((error) => {
+			this.ready = null;
+			throw error;
+		});
+		return this.ready;
+	}
+	async prepare() {
+		let probe = await this.probe();
+		if (probe.kind === "foreign") throw this.foreignError();
+		if (probe.kind === "absent") {
+			this.options.log("Starting the PoseRef server…");
+			this.options.startServer();
+			probe = await this.waitFor((next) => next.kind !== "absent", START_TIMEOUT_MS);
+			if (probe.kind === "foreign") throw this.foreignError();
+			if (probe.kind === "absent") throw new Error("The PoseRef server did not start. Run `npx poseref start` in a terminal to see why.");
+		}
+		if (this.options.openBrowser && probe.kind === "poseref" && probe.tabs === 0 && !this.browserOpened) {
+			this.browserOpened = true;
+			openBrowser(this.baseUrl, this.options.log);
+			await this.waitFor((next) => next.kind === "poseref" && next.tabs > 0, TAB_WAIT_MS);
+		}
+	}
+	async waitFor(done, timeoutMs) {
+		const deadline = Date.now() + timeoutMs;
+		let probe = await this.probe();
+		while (!done(probe) && Date.now() < deadline) {
+			await sleep(POLL_MS);
+			probe = await this.probe();
+		}
+		return probe;
+	}
+	/** Asks the listener to prove it is PoseRef. Any unexpected answer counts as a foreign program. */
+	async probe() {
+		const nonce = newNonce();
+		let response;
+		try {
+			response = await fetch(`${this.baseUrl}/poseref/identify?nonce=${nonce}`, { signal: AbortSignal.timeout(3e3) });
+		} catch {
+			return { kind: "absent" };
+		}
+		try {
+			const body = await response.json();
+			if (response.ok && body.app === "poseref" && verifyIdentityProof(this.options.secret, nonce, body.proof)) return {
+				kind: "poseref",
+				tabs: typeof body.tabs === "number" ? body.tabs : 0
+			};
+		} catch {}
+		return { kind: "foreign" };
+	}
+	foreignError() {
+		return /* @__PURE__ */ new Error(`Port ${this.options.port} is used by another program, so PoseRef did not send it anything. Ask the user to close that program, or to set POSEREF_PORT to a free port for both the agent and PoseRef.`);
+	}
+	async call(method, params) {
+		let response;
+		try {
+			response = await fetch(`${this.baseUrl}/poseref/bridge`, {
+				method: "POST",
+				headers: {
+					"Content-Type": "application/json",
+					Authorization: `Bearer ${bearerToken(this.options.secret)}`
+				},
+				body: JSON.stringify({
+					method,
+					params
+				}),
+				signal: AbortSignal.timeout(REQUEST_TIMEOUT_MS)
+			});
+		} catch (error) {
+			throw new TransportError(error instanceof Error ? error.message : String(error));
+		}
+		const body = await response.json().catch(() => ({}));
+		if (body.ok === true) return body.result;
+		if (body.ok === false && body.error) throw new Error(body.error);
+		throw new Error(`The PoseRef server rejected the request (HTTP ${response.status}${body.error ? `: ${body.error}` : ""}).`);
+	}
+};
+var TransportError = class extends Error {};
+/**
+* Starts `poseref start --no-open` detached from the agent, so the server (and
+* the user's open tab) outlives the agent session that happened to start it.
+*/
+function spawnDetachedServer(cliPath, log) {
+	const child = spawn(process.execPath, [
+		cliPath,
+		"start",
+		"--no-open"
+	], {
+		detached: true,
+		stdio: "ignore",
+		windowsHide: true,
+		env: process.env
+	});
+	child.on("error", (error) => log(`Could not start the PoseRef server: ${error.message}`));
+	child.unref();
+}
+//#endregion
+//#region server/setup.ts
+/** Tools that change the scene. Codex asks before each call unless they are approved in config.toml. */
+var WRITE_TOOLS = ["set_scene", "reach"];
+/**
+* The command agents run to start PoseRef's stdio MCP server. The version is
+* pinned so a later release (or a compromised one) never runs without the user
+* re-running setup. Windows needs `cmd /c` because npx is a .cmd script there.
+*/
+function mcpLaunchCommand(version, platform = process.platform) {
+	if (!/^\d+\.\d+\.\d+(?:-[0-9A-Za-z.]+)?$/.test(version)) throw new Error(`Unexpected version: ${version}`);
+	const npx = [
+		"npx",
+		"-y",
+		`poseref@${version}`,
+		"mcp"
+	];
+	return platform === "win32" ? [
+		"cmd",
+		"/c",
+		...npx
+	] : npx;
+}
+/**
+* Appends approval tables for the write tools that are not configured yet.
+* Append-only on purpose: rewriting the file with a TOML library would drop the
+* user's comments and ordering. Existing tables are left exactly as they are.
+*/
+function appendCodexApprovals(toml, server = "poseref") {
+	const added = WRITE_TOOLS.filter((tool) => {
+		return !new RegExp(`^\\s*\\[\\s*mcp_servers\\.${server}\\.tools\\.${tool}\\s*\\]`, "m").test(toml);
+	});
+	if (added.length === 0) return {
+		text: toml,
+		added
+	};
+	const blocks = added.map((tool) => `[mcp_servers.${server}.tools.${tool}]\napproval_mode = "approve"\n`);
+	return {
+		text: `${toml}${toml.length === 0 || toml.endsWith("\n\n") ? "" : toml.endsWith("\n") ? "\n" : "\n\n"}# Added by \`poseref setup\`: these tools only change the PoseRef tab, and the change can be undone there.
+${blocks.join("\n")}`,
+		added: [...added]
+	};
+}
+/**
+* Environment flags for the registration. Only a non-default POSEREF_PORT is
+* passed on, so agents start and look for PoseRef on the same port as the user.
+* The flags go after the server name: `claude mcp add --env` takes several
+* values and would swallow the name, while `--` ends the list.
+*/
+function registrationEnv(port = resolvePort()) {
+	return port === 47173 ? [] : ["--env", `POSEREF_PORT=${port}`];
+}
+/** Every argument PoseRef passes to another CLI is a fixed word or a version, never user text. */
+var SAFE_ARG = /^[\w@.:/=-]+$/;
+function run(command, args) {
+	for (const arg of [command, ...args]) if (!SAFE_ARG.test(arg)) throw new Error(`Refusing to run a command with an unexpected argument: ${arg}`);
+	const result = spawnSync(command, args, {
+		encoding: "utf8",
+		shell: process.platform === "win32",
+		windowsHide: true,
+		timeout: 6e4
+	});
+	return {
+		ok: result.status === 0,
+		output: `${result.stdout ?? ""}${result.stderr ?? ""}`.trim()
+	};
+}
+function codexConfigPath() {
+	return join(process.env.CODEX_HOME || join(homedir(), ".codex"), "config.toml");
+}
+/** Replacing removes the old entry first (the CLIs refuse duplicates), so a failed add leaves none. */
+var REMOVED_NOTE = " (the previous \"poseref\" entry was already removed; run `npx poseref setup` again)";
+function claudeSteps(launch, env, log) {
+	if (!run("claude", ["--version"]).ok) {
+		log("- Claude Code: not found (skipped)");
+		return [];
+	}
+	const exists = run("claude", [
+		"mcp",
+		"get",
+		"poseref"
+	]).ok;
+	return [{
+		describe: `${exists ? "Replace" : "Add"} the "poseref" MCP server for all projects: claude mcp add --scope user ${["poseref", ...env].join(" ")} -- ${launch.join(" ")}`,
+		apply: () => {
+			if (exists) run("claude", [
+				"mcp",
+				"remove",
+				"poseref",
+				"--scope",
+				"user"
+			]);
+			const added = run("claude", [
+				"mcp",
+				"add",
+				"--scope",
+				"user",
+				"poseref",
+				...env,
+				"--",
+				...launch
+			]);
+			if (!added.ok) throw new Error(`claude mcp add failed${exists ? REMOVED_NOTE : ""}:\n${added.output}`);
+		}
+	}];
+}
+function codexSteps(launch, env, log) {
+	if (!run("codex", ["--version"]).ok) {
+		log("- Codex: not found (skipped)");
+		return [];
+	}
+	const exists = run("codex", [
+		"mcp",
+		"get",
+		"poseref"
+	]).ok;
+	const configPath = codexConfigPath();
+	return [{
+		describe: `${exists ? "Replace" : "Add"} the "poseref" MCP server: codex mcp add ${["poseref", ...env].join(" ")} -- ${launch.join(" ")}`,
+		apply: () => {
+			if (exists) run("codex", [
+				"mcp",
+				"remove",
+				"poseref"
+			]);
+			const added = run("codex", [
+				"mcp",
+				"add",
+				"poseref",
+				...env,
+				"--",
+				...launch
+			]);
+			if (!added.ok) throw new Error(`codex mcp add failed${exists ? REMOVED_NOTE : ""}:\n${added.output}`);
+		}
+	}, {
+		describe: `Let ${WRITE_TOOLS.join(" and ")} run without a prompt each time: append approval settings to ${configPath} (a backup is kept next to it)`,
+		apply: () => {
+			const { text, added } = appendCodexApprovals(existsSync(configPath) ? readFileSync(configPath, "utf8") : "");
+			if (added.length === 0) return;
+			const backup = `${configPath}.poseref-backup-${(/* @__PURE__ */ new Date()).toISOString().replace(/[:.]/g, "-")}`;
+			if (existsSync(configPath)) copyFileSync(configPath, backup);
+			writeFileSync(configPath, text);
+			if (!run("codex", [
+				"mcp",
+				"get",
+				"poseref"
+			]).ok) {
+				if (existsSync(backup)) copyFileSync(backup, configPath);
+				throw new Error(`Codex could not read ${configPath} after the change, so it was restored. Add the approval settings by hand (see the README).`);
+			}
+			if (existsSync(backup)) log(`  backup: ${backup}`);
+		}
+	}];
+}
+async function confirm(question) {
+	const rl = createInterface({
+		input: process.stdin,
+		output: process.stderr
+	});
+	try {
+		return /^y(es)?$/i.test((await rl.question(question)).trim());
+	} finally {
+		rl.close();
+	}
+}
+/**
+* `poseref setup`: registers PoseRef with the agents found on this machine.
+* Shows every change first and asks before making any.
+*/
+async function runSetup(options) {
+	const { log } = options;
+	const launch = mcpLaunchCommand(options.version);
+	log(`PoseRef ${options.version} setup`);
+	log("");
+	const env = registrationEnv();
+	const steps = [...claudeSteps(launch, env, log), ...codexSteps(launch, env, log)];
+	if (steps.length === 0) {
+		log("Neither Claude Code (`claude`) nor Codex (`codex`) was found on PATH. Install one, then run this again.");
+		return 1;
+	}
+	log("This will:");
+	for (const step of steps) log(`- ${step.describe}`);
+	log("");
+	if (options.dryRun) {
+		log("Dry run: nothing was changed.");
+		return 0;
+	}
+	if (!options.yes) {
+		if (!process.stdin.isTTY) {
+			log("Not running in an interactive terminal. Re-run with --yes to apply these changes.");
+			return 1;
+		}
+		if (!await confirm("Apply these changes? [y/N] ")) {
+			log("Nothing was changed.");
+			return 1;
+		}
+	}
+	for (const step of steps) step.apply();
+	log("");
+	log("Done. Restart Claude Code / Codex, then ask for a pose, e.g. \"PoseRefで、腕を組んで立っているポーズを作って\".");
+	log("PoseRef and the browser tab start the first time an agent uses a PoseRef tool.");
+	return 0;
+}
+//#endregion
+//#region server/cli.ts
+var CLI_PATH = fileURLToPath(import.meta.url);
+var DIST_DIR = join(PACKAGE_ROOT, "dist");
+var HELP = `PoseRef ${POSEREF_VERSION}: pose and composition reference maker for image AIs
+
+Usage:
+  npx poseref setup [--yes] [--dry-run]   Register PoseRef with Claude Code and Codex
+  npx poseref [start] [--no-open]         Start PoseRef and open it in the browser
+  npx poseref stop                        Stop a running PoseRef
+  npx poseref mcp                         MCP server over stdio (agents run this; not for direct use)
+
+Environment:
+  POSEREF_PORT     Port to use (default 47173)
+  POSEREF_NO_OPEN  Set to any value to never open the browser automatically
+`;
+/** stderr only: in `mcp` mode stdout carries the MCP protocol and must stay clean. */
+var log = (message) => process.stderr.write(`${message}\n`);
+async function isPoseRefRunning(port, secret) {
+	const nonce = newNonce();
+	try {
+		const body = await (await fetch(`http://127.0.0.1:${port}/poseref/identify?nonce=${nonce}`, { signal: AbortSignal.timeout(3e3) })).json();
+		return body.app === "poseref" && verifyIdentityProof(secret, nonce, body.proof);
+	} catch {
+		return false;
+	}
+}
+async function start(args) {
+	const open = !args.includes("--no-open") && !process.env.POSEREF_NO_OPEN;
+	if (!existsSync(DIST_DIR)) {
+		log("The app build (dist/) is missing. In a clone of the repository, run `npm run build` first.");
+		return 1;
+	}
+	const port = resolvePort();
+	const secret = loadOrCreateSecret();
+	const server = createPoseRefServer({
+		port,
+		staticDir: DIST_DIR,
+		secret,
+		version: POSEREF_VERSION,
+		onShutdown: () => void server.close().then(() => process.exit(0))
+	});
+	try {
+		await server.listen();
+	} catch (error) {
+		if (error.code !== "EADDRINUSE") throw error;
+		if (await isPoseRefRunning(port, secret)) {
+			log(`PoseRef is already running: ${server.appUrl}`);
+			if (open) openBrowser(server.appUrl, log);
+			return 0;
+		}
+		log(`Port ${port} is used by another program. Close it, or set POSEREF_PORT to a free port (and re-run \`npx poseref setup\`).`);
+		return 1;
+	}
+	log(`PoseRef:  ${server.appUrl}`);
+	log(`MCP URL:  ${server.mcpUrl}`);
+	log("Press Ctrl+C to stop.");
+	if (open) openBrowser(server.appUrl, log);
+	const shutdown = () => void server.close().then(() => process.exit(0));
+	process.on("SIGINT", shutdown);
+	process.on("SIGTERM", shutdown);
+	return new Promise(() => {});
+}
+async function mcp() {
+	console.log = console.error;
+	console.info = console.error;
+	const bridge = new RemoteBridge({
+		port: resolvePort(),
+		secret: loadOrCreateSecret(),
+		startServer: () => spawnDetachedServer(CLI_PATH, log),
+		openBrowser: !process.env.POSEREF_NO_OPEN,
+		log
+	});
+	serveStdio(() => createPoseRefMcpServer(bridge));
+	return new Promise(() => {});
+}
+async function stop() {
+	const port = resolvePort();
+	const secret = loadOrCreateSecret();
+	if (!await isPoseRefRunning(port, secret)) {
+		log("PoseRef is not running.");
+		return 0;
+	}
+	const response = await fetch(`http://127.0.0.1:${port}/poseref/shutdown`, {
+		method: "POST",
+		headers: { Authorization: `Bearer ${bearerToken(secret)}` }
+	});
+	log(response.ok ? "PoseRef stopped." : `Could not stop PoseRef (HTTP ${response.status}).`);
+	return response.ok ? 0 : 1;
+}
+async function main(argv) {
+	const [command = "start", ...args] = argv;
+	switch (command) {
+		case "start": return start(args);
+		case "--no-open": return start(argv);
+		case "mcp": return mcp();
+		case "setup": return runSetup({
+			version: POSEREF_VERSION,
+			yes: args.includes("--yes"),
+			dryRun: args.includes("--dry-run"),
+			log
+		});
+		case "stop": return stop();
+		case "--version":
+		case "-v":
+			log(POSEREF_VERSION);
+			return 0;
+		case "help":
+		case "--help":
+		case "-h":
+			log(HELP);
+			return 0;
+		default:
+			log(`Unknown command: ${command}\n\n${HELP}`);
+			return 1;
+	}
+}
+main(process.argv.slice(2)).then((code) => {
+	process.exitCode = code;
+}, (error) => {
+	log(error instanceof Error ? error.message : String(error));
+	process.exitCode = 1;
+});
+//#endregion
+export {};