cozyclay 2.1.1 → 3.0.1

package/tools/loc-baseline.json

@@ -1,126 +1,76 @@
 {
-	"bin/agent/agent-routes.mjs": 903,
+	"bin/agent/agent-routes.mjs": 865,
 	"bin/agent/agent-runner.mjs": 496,
 	"bin/agent/providers.mjs": 409,
 	"bin/agent/session-store.mjs": 324,
-	"bin/agent/studio-rebase.mjs": 268,
 	"bin/agent/supervisor.mjs": 283,
 	"bin/agent/video-adapters.mjs": 334,
-	"bin/cozyclay.mjs": 527,
+	"bin/cozyclay.mjs": 440,
 	"bin/live/cli.mjs": 456,
-	"mcp/live-hub.mjs": 534,
-	"mcp/tool-handlers.mjs": 1890,
-	"mcp/verify-live-batch.mjs": 490,
+	"mcp/live-hub.mjs": 529,
+	"mcp/tool-handlers.mjs": 1730,
+	"mcp/verify-live-batch.mjs": 486,
 	"mcp/verify-live-capture.mjs": 268,
 	"mcp/verify-live-controller.mjs": 340,
-	"mcp/verify-live-motion-job.mjs": 336,
-	"mcp/verify-live-p0.mjs": 287,
-	"mcp/verify-live.mjs": 455,
-	"src/analytics.js": 1181,
-	"src/App.jsx": 6644,
-	"src/ardy/auto-physics.js": 1094,
-	"src/ardy/collision-blockers.js": 273,
-	"src/ardy/convert.js": 285,
-	"src/ardy/fix-collisions.js": 1987,
-	"src/ardy/ik.js": 1135,
-	"src/ardy/npz.js": 534,
-	"src/ardy/physics-review.js": 510,
-	"src/ardy/platform-fit.js": 277,
-	"src/ardy/playback.js": 565,
-	"src/ardy/range-pin.js": 277,
-	"src/ardy/root-drop.js": 313,
-	"src/ardy/timeline.jsx": 2384,
-	"src/ardy/waypoints.js": 311,
+	"mcp/verify-live-p0.mjs": 264,
+	"mcp/verify-live.mjs": 416,
+	"src/analytics.js": 1169,
+	"src/App.jsx": 4711,
 	"src/asset-pane.jsx": 648,
 	"src/camera-follow.js": 505,
 	"src/camera-move.js": 289,
 	"src/camera-tutorial.jsx": 443,
 	"src/command-bus.js": 378,
 	"src/controls.jsx": 340,
-	"src/domains/cast.js": 859,
-	"src/domains/motion.js": 2277,
-	"src/domains/motion/motion-video-capture.js": 592,
+	"src/domains/cast.js": 717,
+	"src/domains/motion.js": 812,
 	"src/domains/objects.js": 907,
-	"src/domains/scenes.js": 801,
+	"src/domains/scenes.js": 754,
 	"src/domains/shots.js": 411,
 	"src/dualview.jsx": 371,
 	"src/hierarchy-panel.jsx": 779,
-	"src/line-edit.js": 1215,
 	"src/live-control.js": 338,
 	"src/matte-editor.js": 486,
 	"src/matte.js": 472,
-	"src/motion-trail.js": 550,
-	"src/multimodel-ingest.js": 344,
+	"src/motion/collision-blockers.js": 273,
+	"src/motion/fix-collisions.js": 748,
+	"src/motion/ik.js": 1135,
+	"src/motion/range-pin.js": 277,
+	"src/motion/timeline.jsx": 2047,
 	"src/object-gizmo.jsx": 824,
 	"src/object-path.js": 410,
 	"src/panels/ObjectTransformPanel.jsx": 545,
-	"src/panels/PromptBlocksPanel.jsx": 433,
 	"src/panels/SculptPanel.jsx": 370,
 	"src/planview.jsx": 887,
 	"src/poses.js": 321,
-	"src/posestudio.jsx": 1263,
+	"src/posestudio.jsx": 1240,
 	"src/project-browser.jsx": 401,
-	"src/project-resources.js": 256,
-	"src/project.js": 691,
-	"src/props.jsx": 649,
+	"src/project.js": 603,
+	"src/props.jsx": 417,
 	"src/range-pin-panel.jsx": 305,
 	"src/scene-assets.js": 400,
 	"src/scene-mesh.js": 350,
-	"src/scene-objects.js": 1233,
-	"src/scenes.js": 456,
+	"src/scene-objects.js": 1136,
+	"src/scenes.js": 387,
 	"src/sculpt-compare.js": 357,
 	"src/sculpt-recipe.js": 363,
 	"src/sculpt-run.js": 309,
 	"src/shell/BoardSlot.jsx": 316,
-	"src/shell/BottomDock.jsx": 460,
-	"src/shell/DetailsSlot.jsx": 517,
+	"src/shell/BottomDock.jsx": 416,
+	"src/shell/DetailsSlot.jsx": 334,
 	"src/shell/MenuBar.jsx": 640,
-	"src/shell/PreferencesDialog.jsx": 516,
-	"src/shell/ViewportToolbar.jsx": 638,
+	"src/shell/PreferencesDialog.jsx": 466,
+	"src/shell/ViewportToolbar.jsx": 567,
 	"src/shot-authoring.js": 348,
 	"src/stage-canvas-rigs.jsx": 352,
 	"src/stage-editor-gizmos.jsx": 1116,
 	"src/studio-agent-commands.js": 492,
-	"src/studio-agent-protocol.js": 521,
-	"src/studio-app-binding.js": 364,
+	"src/studio-agent-protocol.js": 486,
+	"src/studio-app-binding.js": 346,
 	"src/ui.jsx": 393,
 	"src/workflow/agent-client.js": 1386,
-	"src/workflow/AgentPanel.jsx": 894,
-	"src/workflow/WorkflowBuilder.jsx": 608,
-	"tools/ardy/bridge.mjs": 1321,
-	"tools/ardy/bvh-cskel27.mjs": 912,
-	"tools/ardy/extract-rest.mjs": 266,
-	"tools/ardy/extract.mjs": 412,
-	"tools/ardy/footage.mjs": 409,
-	"tools/ardy/motion-stabilize.mjs": 279,
-	"tools/ardy/npz.mjs": 369,
-	"tools/ardy/runners/local.mjs": 367,
-	"tools/bench/extract-bench.mjs": 284,
-	"tools/bench/fit/contact.mjs": 380,
-	"tools/bench/metrics.mjs": 290,
-	"tools/bench/obs-bench.mjs": 486,
-	"tools/bench/obs/ground.mjs": 265,
-	"tools/bench/obs/ladder.mjs": 480,
-	"tools/bench/score.mjs": 316,
-	"tools/demo-worker/generate.mjs": 274,
-	"tools/demo-worker/index.mjs": 426,
-	"tools/gt-render/camera-math.mjs": 255,
-	"tools/gt-render/render.mjs": 485,
-	"tools/kimodo/generate.mjs": 519,
-	"tools/kimodo/local-output.mjs": 255,
-	"tools/kimodo/measure-preserve.mjs": 795,
-	"tools/kimodo/preserve-mask.mjs": 452,
-	"tools/kimodo/soma77-to-cskel27.mjs": 271,
-	"tools/projflow/generate.mjs": 682,
-	"tools/projflow/hml22-to-cskel27.mjs": 633,
-	"tools/projflow/line-edit-job.mjs": 484,
-	"tools/projflow/replay.mjs": 397,
-	"tools/projflow/service.mjs": 651,
+	"src/workflow/AgentPanel.jsx": 880,
+	"src/workflow/WorkflowBuilder.jsx": 592,
 	"tools/qa/css-rule-usage.mjs": 251,
-	"tools/run-tests.mjs": 564,
-	"tools/track/gate.mjs": 325,
-	"tools/track/masks.mjs": 297,
-	"tools/track/study-2d.mjs": 663,
-	"workers/api/src/index.js": 426,
-	"workers/api/src/queue.js": 441
+	"tools/run-tests.mjs": 448
 }

package/tools/motion3/extract-body.mjs

@@ -0,0 +1,103 @@
+// Fit the collision body of a Mixamo FBX rig from its skin to src/motion3/rigs/<model>-body.json
+// for motion3's self-collision (src/motion3/body.js): one signed distance grid per skinned bone, in
+// that bone's bind frame (the bone moves it rigidly), from the skin vertices the bone carries; and
+// for each limb bone the radius of its skin along the bone (the probe spheres a limb collides with).
+// Run once per rig: node tools/motion3/extract-body.mjs y-bot-tpose
+import fs from "node:fs";
+import path from "node:path";
+import * as THREE from "three";
+import { FBXLoader } from "three/examples/jsm/loaders/FBXLoader.js";
+import { skeletonFor } from "../../src/motion3/rigs/index.js";
+import { axisEnd } from "../../src/motion3/body.js";
+import { sub, apply, T, dot, len } from "../../src/motion3/compiler/math.js";
+
+const model = process.argv[2] ?? "y-bot-tpose";
+const STEP = 0.015, MARGIN = 0.04, MEMBER = 0.25, MM = 1000;
+const buf = fs.readFileSync(path.resolve("public/models", `${model}.fbx`));
+const root = new FBXLoader().parse(buf.buffer.slice(buf.byteOffset, buf.byteOffset + buf.byteLength), "");
+root.updateMatrixWorld(true);
+const sk = skeletonFor(model), name = n => n.replace(/^mixamorig:?/, "");
+
+// Skin vertices (metres, bind pose) with normals and the bones that carry them, both meshes (the
+// Y/X Bot joint balls are their own mesh), duplicates merged.
+const verts = new Map();
+root.traverse(o => {
+	if (!o.isSkinnedMesh) return;
+	const g = o.geometry, pos = g.attributes.position, nrm = g.attributes.normal, si = g.attributes.skinIndex, sw = g.attributes.skinWeight;
+	const v = new THREE.Vector3(), n = new THREE.Vector3(), nm = new THREE.Matrix3().getNormalMatrix(o.matrixWorld);
+	for (let i = 0; i < pos.count; i++) {
+		v.fromBufferAttribute(pos, i).applyMatrix4(o.matrixWorld).multiplyScalar(0.01);
+		const key = v.toArray().map(x => Math.round(x * 2000)).join();
+		const entry = verts.get(key) ?? { p: v.toArray(), n: [0, 0, 0], w: new Map() };
+		n.fromBufferAttribute(nrm, i).applyMatrix3(nm).normalize();
+		entry.n = entry.n.map((x, k) => x + n.getComponent(k));
+		for (let k = 0; k < 4; k++) {
+			const w = sw.getComponent(i, k), b = sk.index[name(o.skeleton.bones[si.getComponent(i, k)].name)];
+			if (w > 0 && b !== undefined) entry.w.set(b, Math.max(entry.w.get(b) ?? 0, w));
+		}
+		verts.set(key, entry);
+	}
+});
+const V = [...verts.values()].map(e => ({ ...e, n: e.n.map(x => x / (len(e.n) || 1)) }));
+const dominant = e => [...e.w].sort((a, b) => b[1] - a[1])[0]?.[0];
+// Fingers bend inside the hand: their skin is no grid of the hand; every other skinned bone gets one.
+const FINGER = /Hand(Thumb|Index|Middle|Ring|Pinky)/;
+const owners = [...new Set(V.map(dominant))].filter(b => b !== undefined && !FINGER.test(sk.names[b]));
+
+/** Signed distance grid of the skin bone b carries, in b's bind frame (millimetres, Int8, outside +). */
+function grid(b) {
+	const toLocal = p => apply(T(sk.restWorldRot[b]), sub(p, sk.restWorldPos[b]));
+	const pts = V.filter(e => (e.w.get(b) ?? 0) >= MEMBER || dominant(e) === b).map(e => ({ p: toLocal(e.p), n: apply(T(sk.restWorldRot[b]), e.n) }));
+	const own = V.filter(e => dominant(e) === b).map(e => toLocal(e.p));
+	const lo = [0, 1, 2].map(k => Math.min(...own.map(p => p[k])) - MARGIN), hi = [0, 1, 2].map(k => Math.max(...own.map(p => p[k])) + MARGIN);
+	const dims = lo.map((l, k) => Math.max(2, Math.ceil((hi[k] - l) / STEP) + 1));
+	// a hash of the member points: the nearest few decide distance and side
+	const cell = 0.03, hash = new Map(), at = p => p.map(x => Math.floor(x / cell)).join();
+	for (const q of pts) { const k = at(q.p); if (!hash.has(k)) hash.set(k, []); hash.get(k).push(q); }
+	const near = p => {
+		const c = p.map(x => Math.floor(x / cell)), found = [];
+		for (let r = 1; r <= 6 && found.length < 6; r++) {
+			found.length = 0;
+			for (let i = -r; i <= r; i++) for (let j = -r; j <= r; j++) for (let k = -r; k <= r; k++) found.push(...(hash.get(`${c[0] + i},${c[1] + j},${c[2] + k}`) ?? []));
+		}
+		return found.map(q => ({ q, d: len(sub(p, q.p)) })).sort((x, y) => x.d - y.d).slice(0, 6);
+	};
+	const data = new Int8Array(dims[0] * dims[1] * dims[2]);
+	for (let x = 0; x < dims[0]; x++) for (let y = 0; y < dims[1]; y++) for (let z = 0; z < dims[2]; z++) {
+		const p = [lo[0] + x * STEP, lo[1] + y * STEP, lo[2] + z * STEP], nn = near(p);
+		let d = 0.127;
+		if (nn.length) {
+			// side: the nearest points' normals vote, nearer ones louder; distance: to the nearest point's
+			// tangent plane where the point lies over it, else to the point
+			const side = nn.reduce((acc, { q, d: dq }) => acc + Math.sign(dot(sub(p, q.p), q.n)) / (dq + 0.005), 0) >= 0 ? 1 : -1;
+			const { q, d: dq } = nn[0], along = Math.abs(dot(sub(p, q.p), q.n)), lateral = Math.sqrt(Math.max(0, dq * dq - along * along));
+			d = side * (lateral < STEP ? along : dq);
+		}
+		data[(x * dims[1] + y) * dims[2] + z] = Math.max(-127, Math.min(127, Math.round(d * MM)));
+	}
+	return { min: lo.map(v => +v.toFixed(4)), dims, data: Buffer.from(data.buffer).toString("base64") };
+}
+
+/** Skin radius along a limb bone (bone to its first child), [t, r] at 6 stations: the 80th percentile of
+ * the skin's distance from the bone, but for a hand the median capped at HAND (the palm is flat, and the
+ * thumb's root rides the hand bone: a round 80th percentile would make it a 10 cm ball); HAND is the palm's half thickness (qa/geometry.js hand_*). */
+const HAND = 0.022;
+function profile(b) {
+	const hand = /Hand$/.test(sk.names[b]);
+	const child = axisEnd(sk, b), A = sk.restWorldPos[b], B = sk.restWorldPos[child], axis = sub(B, A), L2 = dot(axis, axis);
+	const bins = Array.from({ length: 6 }, () => []);
+	for (const e of V) {
+		if (dominant(e) !== b) continue;
+		const t = dot(sub(e.p, A), axis) / L2;
+		if (t < 0 || t > 1) continue;
+		bins[Math.min(5, Math.floor(t * 6))].push(len(sub(sub(e.p, A), axis.map(v => v * t))));
+	}
+	const pick = r => { const v = r.sort((x, y) => x - y)[Math.floor(r.length * (hand ? 0.5 : 0.8))]; return +(hand ? Math.min(HAND, v) : v).toFixed(4); };
+	return bins.map((r, i) => [+((i + 0.5) / 6).toFixed(3), r.length ? pick(r) : null]).filter(([, r]) => r !== null);
+}
+
+const LIMBS = ["Arm", "ForeArm", "Hand", "UpLeg", "Leg"].flatMap(n => [`Left${n}`, `Right${n}`]);
+const out = { model, step: STEP, unit: "mm", grids: Object.fromEntries(owners.map(b => [sk.names[b], grid(b)])), radii: Object.fromEntries(LIMBS.map(n => [n, profile(sk.index[n])])) };
+const file = path.resolve("src/motion3/rigs", `${model}-body.json`);
+fs.writeFileSync(file, `${JSON.stringify(out)}\n`);
+console.log(`${file}: ${owners.length} grids, ${(fs.statSync(file).size / 1024).toFixed(0)} KB`);

package/tools/motion3/extract-rig.mjs

@@ -0,0 +1,85 @@
+// Dump a Mixamo FBX rig's bind skeleton plus measured face/body landmarks to
+// src/motion3/rigs/<model>.json for the motion3 compiler.
+// Run once per rig: node tools/motion3/extract-rig.mjs x-bot-tpose
+import fs from "node:fs";
+import path from "node:path";
+import * as THREE from "three";
+import { FBXLoader } from "three/examples/jsm/loaders/FBXLoader.js";
+
+const model = process.argv[2] ?? "x-bot-tpose";
+const buf = fs.readFileSync(path.resolve("public/models", `${model}.fbx`));
+const root = new FBXLoader().parse(buf.buffer.slice(buf.byteOffset, buf.byteOffset + buf.byteLength), "");
+root.updateMatrixWorld(true);
+let mesh = null;
+root.traverse(o => { if (o.isSkinnedMesh && (!mesh || o.skeleton.bones.length > mesh.skeleton.bones.length)) mesh = o; });
+// The whole bone hierarchy under the skinned Hips, end bones included (some rigs do not skin them).
+const bones = [];
+// Mixamo FBX nests an identity "skinned" copy of every bone under its control bone; the
+// project rule (src/ardy/playback.js findBone) is first depth-first match wins, so keep
+// the first bone of each name and never the nested copies.
+const seen = new Set();
+let top0 = mesh.skeleton.bones[0];
+while (top0.parent?.isBone) top0 = top0.parent;   // skinned bones may be the nested copies
+top0.traverse(o => { if (o.isBone && !seen.has(o.name)) { seen.add(o.name); bones.push(o); } });
+const idx = new Map(bones.map((b, i) => [b, i]));
+const name = b => b.name.replace(/^mixamorig:?/, "");
+const v = new THREE.Vector3(), q = new THREE.Quaternion(), s = new THREE.Vector3();
+const out = { model, units: "cm", mesh: mesh.name, bones: bones.map(b => {
+	b.matrixWorld.decompose(v, q, s);
+	return { name: name(b), parent: idx.has(b.parent) ? idx.get(b.parent) : -1, localPos: b.position.toArray(), localQuat: b.quaternion.toArray(),
+		worldPos: v.toArray(), worldQuat: q.toArray() };
+}) };
+// Bind-pose vertices in world space (skinning at bind pose is the identity).
+const pos = mesh.geometry.attributes.position, P = [];
+for (let i = 0; i < pos.count; i++) P.push(v.fromBufferAttribute(pos, i).applyMatrix4(mesh.matrixWorld).toArray());
+const B = n => out.bones.find(b => b.name === n).worldPos;
+const head = B("Head"), neck = B("Neck");
+// HeadTop_End is not in every rig (Y Bot has none): fall back to the highest skin vertex.
+const top = out.bones.find(b => b.name === "HeadTop_End")?.worldPos
+	?? [head[0], Math.max(...P.filter(p => p[1] > head[1]).map(p => p[1])), head[2]];
+// Head profile on the mid-sagittal strip |x| < 1.5 cm: the face is the front (+z) silhouette.
+const strip = P.filter(p => Math.abs(p[0]) < 1.5 && p[1] > neck[1] && p[1] < top[1] + 2);
+const rows = [];
+for (let y = Math.floor(neck[1]); y < top[1]; y += 1) {
+	const r = strip.filter(p => p[1] >= y && p[1] < y + 1);
+	if (r.length) rows.push({ y: y + 0.5, front: Math.max(...r.map(p => p[2])), back: Math.min(...r.map(p => p[2])) });
+}
+// Head skin only: from 6 cm below the head joint up, inside |x| < 12 cm (keeps the shoulders out).
+const headVerts = P.filter(p => p[1] > head[1] - 6 && Math.abs(p[0]) < 12);
+const ext = k => [Math.min(...headVerts.map(p => p[k])), Math.max(...headVerts.map(p => p[k]))];
+const hb = { x: ext(0), y: ext(1), z: ext(2) };
+// The bot head has no modelled mouth: put it 16% of the head height above the chin, on
+// the front silhouette (interpolated from the profile rows), 0.3 cm proud of the skin.
+const mouthY = hb.y[0] + 0.16 * (hb.y[1] - hb.y[0]);
+const near = rows.filter(r => r.front > 0).sort((a, b) => Math.abs(a.y - mouthY) - Math.abs(b.y - mouthY)).slice(0, 3);
+const mouthZ = Math.max(...near.map(r => r.front)) + 0.3;
+// The left foot's skin (every skinned mesh, vertices at least half weighted to LeftFoot/LeftToe*,
+// the membership the verify_result floor measure uses). QA's ball and tip sole points ride the
+// ToeBase and Toe_End joints this far down (cm, to the mm; < 0: the skin is above the joint):
+// ball = the lowest skin under the toe pad (from ToeBase halfway to Toe_End), tip = the lowest
+// skin in the front 1.5 cm of the foot.
+const footSkin = [];
+root.traverse(m => {
+	const g = m.isSkinnedMesh && m.geometry.attributes, wp = new THREE.Vector3();
+	if (!g?.skinIndex) return;
+	for (let i = 0; i < g.position.count; i++) {
+		let w = 0;
+		for (let j = 0; j < 4; j++) if (/LeftFoot|LeftToe/.test(m.skeleton.bones[g.skinIndex.getComponent(i, j)]?.name ?? "")) w += g.skinWeight.getComponent(i, j);
+		if (w >= 0.5) footSkin.push(wp.fromBufferAttribute(g.position, i).applyMatrix4(m.matrixWorld).toArray());
+	}
+});
+const toe = B("LeftToeBase"), toeEnd = B("LeftToe_End"), front = Math.max(...footSkin.map(p => p[2]));
+const lowest = (z0, z1) => Math.min(...footSkin.filter(p => p[2] >= z0 && p[2] <= z1).map(p => p[1]));
+const mm = x => Math.round(x * 10) / 10 || 0;
+out.landmarks = {
+	// all in bind-pose world cm; the compiler re-expresses them in the Head bone frame
+	mouth: [0, mouthY, mouthZ],
+	headEllipsoid: { centre: [(hb.x[0] + hb.x[1]) / 2, (hb.y[0] + hb.y[1]) / 2, (hb.z[0] + hb.z[1]) / 2],
+		radii: [(hb.x[1] - hb.x[0]) / 2, (hb.y[1] - hb.y[0]) / 2, (hb.z[1] - hb.z[0]) / 2] },
+	headJoint: head, headTop: top,
+	sole: { ball: mm(toe[1] - lowest(toe[2], (toe[2] + toeEnd[2]) / 2)), tip: mm(toeEnd[1] - lowest(front - 1.5, front)) },
+};
+const file = path.resolve("src/motion3/rigs", `${model}.json`);
+fs.mkdirSync(path.dirname(file), { recursive: true });
+fs.writeFileSync(file, JSON.stringify(out));
+console.log(JSON.stringify({ file, bones: out.bones.length, verts: P.length, landmarks: out.landmarks }));

package/tools/process-supervisor.mjs

@@ -27,94 +27,6 @@ export function waitForExit(child) {
 	});
 }
 
-function bridgeError(name, port, detail, code) {
-	const error = new Error(`${name} on 127.0.0.1:${port} ${detail}`);
-	error.code = code;
-	return error;
-}
-
-function waitForBridgeReady(child, { name, port, readyType, listenErrorType }, timeoutMs = 5000) {
-	return new Promise((resolve, reject) => {
-		let settled = false;
-		const finish = (callback, value) => {
-			if (settled) return;
-			settled = true;
-			clearTimeout(timeout);
-			child.off("message", onMessage);
-			child.off("exit", onExit);
-			child.off("error", onError);
-			callback(value);
-		};
-		const fail = (detail, code) => finish(reject, bridgeError(name, port, detail, code));
-		const onMessage = (message) => {
-			if (!message || message.port !== port) return;
-			if (message.type === readyType) finish(resolve);
-			if (message.type === listenErrorType) {
-				fail(`could not listen: ${message.code ?? "unknown error"}`, message.code);
-			}
-		};
-		const onExit = (code, signal) => fail(`exited ${signal ? `from ${signal}` : `with code ${code ?? 0}`}`);
-		const onError = (error) => fail(`could not start: ${error.message}`);
-		const timeout = setTimeout(() => fail(`did not report readiness within ${timeoutMs} ms`), timeoutMs);
-		child.on("message", onMessage);
-		child.once("exit", onExit);
-		child.once("error", onError);
-	});
-}
-
-export async function startBridge({
-	command,
-	args,
-	cwd,
-	env,
-	mainPort,
-	portEnv = "COZYCLAY_BRIDGE_PORT",
-	name = "motion bridge",
-	readyType = "cozyclay-bridge-ready",
-	listenErrorType = "cozyclay-bridge-listen-error",
-	onSpawn,
-	onFailure,
-	onReady,
-}) {
-	const explicitPort = env[portEnv];
-	if (explicitPort !== undefined) {
-		const port = Number(explicitPort);
-		if (!Number.isInteger(port) || port < 1 || port > 65535) {
-			throw new Error(`${portEnv}=${JSON.stringify(explicitPort)} is not a valid port`);
-		}
-		return startBridgeAt(port, true);
-	}
-	for (let port = mainPort + 1; port <= 65535; port += 1) {
-		try {
-			return await startBridgeAt(port, false);
-		} catch (error) {
-			if (error?.code !== "EADDRINUSE") throw error;
-		}
-	}
-	throw new Error(`no free bridge port is available at or above ${mainPort + 1}`);
-
-	async function startBridgeAt(port, isExplicit) {
-		const child = spawnOwned(command, args, {
-			cwd,
-			env: { ...env, [portEnv]: String(port) },
-			stdio: ["inherit", "inherit", "inherit", "ipc"],
-		});
-		onSpawn?.(child);
-		try {
-			await waitForBridgeReady(child, { name, port, readyType, listenErrorType });
-			onReady?.(child);
-			return { child, port };
-		} catch (error) {
-			onFailure?.(child);
-			await terminateOwned(child);
-			if (isExplicit && error?.code === "EADDRINUSE") {
-				throw new Error(`${portEnv}=${port} is already in use; choose another ${portEnv}`);
-			}
-			throw error;
-		}
-	}
-}
-
 function signalOwned(child, signal) {
 	if (!child || child.exitCode !== null || child.signalCode !== null) return;
 	try {