@classytic/labs 0.2.0 → 0.3.0

package/dist/physics/force-pairs/preset.mjs

@@ -0,0 +1,833 @@
+'use client';
+
+import { Tex as Tex$1 } from "../../core/tex.mjs";
+import { ActivitySelect, Slider } from "../../kit/controls.mjs";
+import { Control, Field } from "../../kit/frame.mjs";
+import { AuthoredActivityRuntime, AuthoredMetricGate } from "../../kit/authored-activity-runtime.mjs";
+import { MechanicsVector, SceneSurface } from "../mechanics/presentation.mjs";
+import { useState } from "react";
+import { Fragment as Fragment$1, jsx, jsxs } from "react/jsx-runtime";
+import { Circle, Label, Polygon, Polyline, Segment, Stage } from "@classytic/stage";
+
+//#region src/physics/force-pairs/preset.tsx
+/**
+* ForcePairsLab, Newton's third law drawn as TWO BODIES, never one.
+*
+* The whole difficulty of the third law is a drawing habit. A learner who has only ever seen
+* "action and reaction" written as two arrows on one picture concludes that they cancel, and then
+* cannot explain why anything ever accelerates. So this figure refuses to draw them together:
+* each body sits inside its own dashed system boundary, with a visible gap between the two, and
+* every arrow that belongs to a body is drawn INSIDE that body's boundary. Nothing in the figure
+* can be added up across the gap, because the gap is the point. The only thing that crosses it is
+* a hairline marking the one interaction the two forces come from.
+*
+* Three things the figure has to carry, in the order they matter:
+*   1. DIFFERENT BODIES. "force A on B" lives in B's box; "force B on A" lives in A's box. The
+*      names are written out in words rather than as F_AB subscripts, because a subscript at a
+*      legible base size drops below the 12 px on-screen floor, and because "A on B" is the
+*      sentence a learner has to be able to say out loud.
+*   2. EQUAL FORCES, UNEQUAL ACCELERATIONS. The force arrows are drawn from the force slider ONLY:
+*      dragging either mass slider does not move them by a pixel. The acceleration arrows below
+*      are normalised so the larger one always spans the same distance, which makes their LENGTH
+*      RATIO exactly the mass ratio, F/m_A : F/m_B. That contrast, seen in one glance while a mass
+*      slider moves, is the horse-and-cart resolution.
+*   3. NOT EVERY EQUAL-AND-OPPOSITE PAIR IS A PAIR. Weight and the table's push act on the SAME
+*      body, so they fail test 1. Drawing that counter-example would need a third body and a
+*      vertical axis and would wreck the figure, so it lives in the explain step instead, where
+*      the learner meets it as a question rather than as decoration.
+*
+* The bodies are drawn the same size whatever their mass. A body that grew with its mass would
+* invite exactly the reading the lab exists to kill, that the bigger thing pushes harder; the
+* mass is a number under each body instead, and the size difference the learner is meant to feel
+* shows up only where it belongs, in the acceleration arrows.
+*
+* Every scenario is frictionless on purpose (ice, orbit, vacuum). On a rough floor a = F/m is a
+* lie, since the ground supplies a second horizontal force, and a lab whose arithmetic the learner
+* cannot reproduce teaches nothing. A person pushing a crate therefore happens in a space station.
+*/
+const FORCE = "var(--stage-accent)";
+const ACCEL = "var(--stage-warn)";
+const BODY = "var(--stage-fg)";
+const BODY_A = "var(--stage-accent)";
+const BODY_B = "var(--stage-accent-2)";
+const SOFT = "var(--stage-muted)";
+/** Scene geometry, in the Stage's own units. Kept together so a tweak cannot desynchronise. */
+const VIEW = {
+	xMin: -11,
+	xMax: 11,
+	yMin: -3,
+	yMax: 5.4
+};
+const BODY_X = 5.6;
+const Y_FORCE = 2.05;
+const Y_ACCEL = -1.35;
+const PANEL_GAP = .35;
+const PANEL_X = 10.9;
+const PANEL_TOP = 4.75;
+const PANEL_BOTTOM = -2.5;
+const F_MAX = 400;
+const A_ARROW_MAX = 4.8;
+const A_ARROW_MIN = .5;
+const SCENARIOS = {
+	skaters: {
+		chip: "two skaters",
+		status: "skaters on ice",
+		nameA: "skater A",
+		nameB: "skater B",
+		glyphA: "person",
+		glyphB: "person",
+		contact: "palms in contact"
+	},
+	push: {
+		chip: "person + crate",
+		status: "astronaut and crate",
+		nameA: "astronaut",
+		nameB: "crate",
+		glyphA: "person",
+		glyphB: "crate",
+		contact: "hand on crate"
+	},
+	rocket: {
+		chip: "rocket + exhaust",
+		status: "rocket and exhaust",
+		nameA: "rocket",
+		nameB: "exhaust gas",
+		glyphA: "rocket",
+		glyphB: "gas",
+		contact: "gas thrown out of the nozzle"
+	}
+};
+const FORCE_PAIRS_ACTIVITY = {
+	pattern: "investigation",
+	title: "Newton’s third law: the pair acts on two bodies",
+	objectives: [
+		"Name the two bodies a force pair acts on",
+		"Keep the pair equal while the masses differ",
+		"Explain why equal forces do not cancel"
+	],
+	steps: [
+		{
+			id: "predict",
+			phase: "predict",
+			title: "Predict who pushes harder",
+			lead: "Commit before you touch a slider.",
+			success: "pair-answer"
+		},
+		{
+			id: "act",
+			phase: "act",
+			title: "Make the masses very different",
+			lead: "Drag either mass slider and watch the two force arrows, not the bodies.",
+			controls: true,
+			reveal: ["model"],
+			success: "mass-changed"
+		},
+		{
+			id: "observe",
+			phase: "observe",
+			title: "Compare the two bands of arrows",
+			lead: "The force arrows stayed the same length. The acceleration arrows did not.",
+			controls: true,
+			reveal: ["model", "evidence"]
+		},
+		{
+			id: "explain",
+			phase: "explain",
+			title: "Decide what is not a pair",
+			lead: "A pair needs two bodies. Equal and opposite is not enough, so test this everyday case before you trust the rule.",
+			reveal: ["model", "evidence"],
+			success: "not-a-pair-answer"
+		},
+		{
+			id: "transfer",
+			phase: "transfer",
+			title: "Find the same pair somewhere else",
+			lead: "Switch the situation. The bodies change; the rule that the two arrows sit in different boxes does not.",
+			controls: true,
+			reveal: ["model", "evidence"],
+			success: "scenario-changed"
+		}
+	],
+	questions: [{
+		id: "pair",
+		prompt: "Body A is much heavier than body B. While the two bodies interact…",
+		choices: [
+			{
+				value: "equal",
+				label: "each pushes the other equally hard; the lighter body accelerates more"
+			},
+			{
+				value: "heavier",
+				label: "the heavier body pushes harder"
+			},
+			{
+				value: "cancel",
+				label: "the forces cancel because they are equal and opposite"
+			},
+			{
+				value: "lighter",
+				label: "the lighter body pushes harder"
+			}
+		],
+		answer: "equal",
+		explain: "One contact, one pair, two equal forces. They cannot cancel, because they act on different bodies: the push on the heavy skater is the only horizontal force on her, and the push on the light skater is the only one on him. Same force, smaller mass, bigger acceleration.",
+		tryAgain: "Two forces only cancel when they act on the same body. Check which body each of these two forces is applied to."
+	}, {
+		id: "not-a-pair",
+		prompt: "A book rests on a table. Earth pulls the book down with 12 N; the table pushes the book up with 12 N. Are those two a Newton’s-third-law pair?",
+		choices: [
+			{
+				value: "same-body",
+				label: "No — both of them act on the book, so they are not a pair"
+			},
+			{
+				value: "yes",
+				label: "Yes — they are equal and opposite"
+			},
+			{
+				value: "not-equal",
+				label: "No — they are not really equal, or the book would float"
+			}
+		],
+		answer: "same-body",
+		explain: "They balance on one body, which is Newton’s first law, not the third. The partner of the book’s weight is the book pulling the Earth up. The partner of the table’s push on the book is the book pushing down on the table. Each real pair has one arrow in each box.",
+		tryAgain: "Draw the two boxes. If both arrows land in the same box, it is not a pair."
+	}],
+	success: [
+		{
+			id: "pair-answer",
+			source: "answer",
+			key: "pair",
+			operator: "eq",
+			value: "equal",
+			pendingLabel: "Predict how the interaction forces compare."
+		},
+		{
+			id: "mass-changed",
+			source: "metric",
+			key: "massChanged",
+			operator: "eq",
+			value: true,
+			pendingLabel: "Change one of the two masses."
+		},
+		{
+			id: "not-a-pair-answer",
+			source: "answer",
+			key: "not-a-pair",
+			operator: "eq",
+			value: "same-body",
+			pendingLabel: "Decide whether weight and the table’s push are a pair."
+		},
+		{
+			id: "scenario-changed",
+			source: "metric",
+			key: "scenarioChanged",
+			operator: "eq",
+			value: true,
+			pendingLabel: "Switch to another situation."
+		}
+	]
+};
+/** 1 significant place below 100, none above, so a 400 m/s² arrow does not print as 400.0. */
+const fmtA = (a) => a >= 100 ? a.toFixed(0) : a.toFixed(1);
+/**
+* One body, drawn facing its partner. `dir` is +1 when the other body lies to the right, so a
+* single set of coordinates serves both halves of the mirror-image figure.
+*/
+function BodyGlyph({ kind, cx, dir, color }) {
+	if (kind === "person") return /* @__PURE__ */ jsxs(Fragment$1, { children: [
+		/* @__PURE__ */ jsx(Circle, {
+			center: {
+				x: cx - dir * .24,
+				y: 3.02
+			},
+			r: .42,
+			color,
+			fill: color,
+			fillOpacity: .92,
+			weight: 2
+		}),
+		/* @__PURE__ */ jsx(Polygon, {
+			points: [
+				{
+					x: cx - dir * .72,
+					y: 2.5
+				},
+				{
+					x: cx + dir * .28,
+					y: 2.55
+				},
+				{
+					x: cx + dir * .4,
+					y: 1.48
+				},
+				{
+					x: cx - dir * .62,
+					y: 1.42
+				}
+			],
+			color,
+			fill: color,
+			fillOpacity: .78,
+			weight: 2.25
+		}),
+		/* @__PURE__ */ jsx(Polyline, {
+			points: [
+				{
+					x: cx - dir * .08,
+					y: 2.35
+				},
+				{
+					x: cx + dir * .48,
+					y: 2.2
+				},
+				{
+					x: cx + dir * 1.15,
+					y: 2.05
+				}
+			],
+			color,
+			weight: 3
+		}),
+		/* @__PURE__ */ jsx(Polyline, {
+			points: [
+				{
+					x: cx - dir * .88,
+					y: .75
+				},
+				{
+					x: cx - dir * .42,
+					y: 1.46
+				},
+				{
+					x: cx + dir * .32,
+					y: .8
+				}
+			],
+			color,
+			weight: 3
+		}),
+		/* @__PURE__ */ jsx(Segment, {
+			from: {
+				x: cx - 1.2,
+				y: .68
+			},
+			to: {
+				x: cx + .9,
+				y: .68
+			},
+			color: SOFT,
+			weight: 2.5
+		})
+	] });
+	if (kind === "crate") return /* @__PURE__ */ jsxs(Fragment$1, { children: [
+		/* @__PURE__ */ jsx(Polygon, {
+			points: [
+				{
+					x: cx - 1.2,
+					y: .85
+				},
+				{
+					x: cx + 1.2,
+					y: .85
+				},
+				{
+					x: cx + 1.2,
+					y: 2.92
+				},
+				{
+					x: cx - 1.2,
+					y: 2.92
+				}
+			],
+			color,
+			fill: color,
+			fillOpacity: .18,
+			weight: 2.5
+		}),
+		/* @__PURE__ */ jsx(Polygon, {
+			points: [
+				{
+					x: cx - 1.2,
+					y: 2.92
+				},
+				{
+					x: cx - .62,
+					y: 3.35
+				},
+				{
+					x: cx + 1.72,
+					y: 3.35
+				},
+				{
+					x: cx + 1.2,
+					y: 2.92
+				}
+			],
+			color,
+			fill: color,
+			fillOpacity: .32,
+			weight: 2
+		}),
+		/* @__PURE__ */ jsx(Segment, {
+			from: {
+				x: cx,
+				y: .85
+			},
+			to: {
+				x: cx,
+				y: 2.92
+			},
+			color,
+			weight: 1.25,
+			opacity: .55
+		})
+	] });
+	if (kind === "rocket") {
+		const n = -dir;
+		return /* @__PURE__ */ jsxs(Fragment$1, { children: [
+			/* @__PURE__ */ jsx(Polygon, {
+				points: [
+					{
+						x: cx + n * 1.75,
+						y: Y_FORCE
+					},
+					{
+						x: cx + n * .55,
+						y: 2.7699999999999996
+					},
+					{
+						x: cx - n * 1.25,
+						y: 2.7699999999999996
+					},
+					{
+						x: cx - n * 1.25,
+						y: Y_FORCE - .72
+					},
+					{
+						x: cx + n * .55,
+						y: Y_FORCE - .72
+					}
+				],
+				color,
+				fill: color,
+				fillOpacity: .14,
+				weight: 2.5
+			}),
+			/* @__PURE__ */ jsx(Polygon, {
+				points: [
+					{
+						x: cx - n * .55,
+						y: 2.7699999999999996
+					},
+					{
+						x: cx - n * 1.45,
+						y: 3.4
+					},
+					{
+						x: cx - n * 1.45,
+						y: 2.7699999999999996
+					}
+				],
+				color,
+				fill: color,
+				fillOpacity: .14,
+				weight: 2
+			}),
+			/* @__PURE__ */ jsx(Polygon, {
+				points: [
+					{
+						x: cx - n * .55,
+						y: Y_FORCE - .72
+					},
+					{
+						x: cx - n * 1.45,
+						y: Y_FORCE - 1.35
+					},
+					{
+						x: cx - n * 1.45,
+						y: Y_FORCE - .72
+					}
+				],
+				color,
+				fill: color,
+				fillOpacity: .14,
+				weight: 2
+			})
+		] });
+	}
+	return /* @__PURE__ */ jsx(Fragment$1, { children: [
+		[
+			0,
+			0,
+			.62
+		],
+		[
+			-.95,
+			.5,
+			.45
+		],
+		[
+			.95,
+			-.45,
+			.45
+		],
+		[
+			-.75,
+			-.62,
+			.38
+		],
+		[
+			.8,
+			.65,
+			.4
+		],
+		[
+			1.65,
+			.15,
+			.3
+		],
+		[
+			-1.65,
+			-.1,
+			.32
+		]
+	].map(([dx, dy, r], i) => /* @__PURE__ */ jsx(Circle, {
+		center: {
+			x: cx + dx,
+			y: Y_FORCE + dy
+		},
+		r,
+		color,
+		fill: color,
+		fillOpacity: .24,
+		weight: 1.75
+	}, i)) });
+}
+/** The dashed system boundary that makes "different bodies" structural rather than captioned. */
+function SystemBox({ x0, x1 }) {
+	const corners = [
+		{
+			x: x0,
+			y: PANEL_BOTTOM
+		},
+		{
+			x: x1,
+			y: PANEL_BOTTOM
+		},
+		{
+			x: x1,
+			y: PANEL_TOP
+		},
+		{
+			x: x0,
+			y: PANEL_TOP
+		}
+	];
+	return /* @__PURE__ */ jsxs(Fragment$1, { children: [/* @__PURE__ */ jsx(Polygon, {
+		points: corners,
+		color: "transparent",
+		fill: BODY,
+		fillOpacity: .035,
+		weight: 0
+	}), /* @__PURE__ */ jsx(Polyline, {
+		points: [...corners, corners[0]],
+		color: SOFT,
+		weight: 1.25,
+		opacity: .5,
+		dashed: true
+	})] });
+}
+function ForcePairsLab({ scenario: scenario0 = "skaters", forceN = 200, massAKg = 80, massBKg = 20, title = "Newton’s third law: force pairs", prompt = "Every push is shared by two bodies. Separate them and the two forces can never be added together, however different the masses are.", objectives, activity = "force-pairs" } = {}) {
+	const activityId = typeof activity === "string" ? activity : "force-pairs";
+	const authoredActivity = typeof activity === "string" ? FORCE_PAIRS_ACTIVITY : activity;
+	const [scenario, setScenario] = useState(scenario0);
+	const [force, setForce] = useState(forceN);
+	const [massA, setMassA] = useState(massAKg);
+	const [massB, setMassB] = useState(massBKg);
+	const scene = SCENARIOS[scenario];
+	const accelA = force / massA;
+	const accelB = force / massB;
+	const forceLen = 2.8 + 2 * (force / F_MAX);
+	const accelMax = Math.max(accelA, accelB);
+	const accelLen = (a) => Math.max(A_ARROW_MIN, A_ARROW_MAX * (a / accelMax));
+	const lenA = accelLen(accelA);
+	const lenB = accelLen(accelB);
+	const forceLabelX = (12.799999999999999 + forceLen) / 2;
+	const figure = /* @__PURE__ */ jsx(SceneSurface, { children: /* @__PURE__ */ jsxs(Stage, {
+		view: VIEW,
+		height: 340,
+		preserveAspect: false,
+		ariaLabel: "Two separated bodies, each inside its own boundary, each carrying one force of the pair and its own acceleration",
+		children: [
+			/* @__PURE__ */ jsx(SystemBox, {
+				x0: -10.9,
+				x1: -.35
+			}),
+			/* @__PURE__ */ jsx(SystemBox, {
+				x0: PANEL_GAP,
+				x1: PANEL_X
+			}),
+			/* @__PURE__ */ jsx(Label, {
+				x: 0,
+				y: 5.1,
+				text: "two different bodies",
+				color: BODY,
+				size: 14,
+				weight: 700
+			}),
+			/* @__PURE__ */ jsx(Segment, {
+				from: {
+					x: -3.8,
+					y: Y_FORCE
+				},
+				to: {
+					x: 3.8,
+					y: Y_FORCE
+				},
+				color: SOFT,
+				weight: 1.25,
+				opacity: .55,
+				dashed: true
+			}),
+			/* @__PURE__ */ jsx(Label, {
+				x: 0,
+				y: 2.62,
+				text: scene.contact,
+				color: SOFT,
+				size: 13,
+				weight: 600
+			}),
+			/* @__PURE__ */ jsx(BodyGlyph, {
+				kind: scene.glyphA,
+				cx: -5.6,
+				dir: 1,
+				color: BODY_A
+			}),
+			/* @__PURE__ */ jsx(BodyGlyph, {
+				kind: scene.glyphB,
+				cx: BODY_X,
+				dir: -1,
+				color: BODY_B
+			}),
+			/* @__PURE__ */ jsx(MechanicsVector, {
+				tail: {
+					x: -5.6,
+					y: Y_FORCE
+				},
+				tip: {
+					x: -5.6 - forceLen,
+					y: Y_FORCE
+				},
+				color: FORCE,
+				weight: 3.5,
+				label: `force B on A · ${force} N`,
+				labelAt: {
+					x: -forceLabelX,
+					y: 4.12
+				}
+			}),
+			/* @__PURE__ */ jsx(MechanicsVector, {
+				tail: {
+					x: BODY_X,
+					y: Y_FORCE
+				},
+				tip: {
+					x: BODY_X + forceLen,
+					y: Y_FORCE
+				},
+				color: FORCE,
+				weight: 3.5,
+				label: `force A on B · ${force} N`,
+				labelAt: {
+					x: forceLabelX,
+					y: 4.12
+				}
+			}),
+			/* @__PURE__ */ jsx(Label, {
+				x: -5.6,
+				y: .28,
+				text: `A \u00b7 ${scene.nameA} \u00b7 ${massA} kg`,
+				color: BODY,
+				size: 14,
+				weight: 650
+			}),
+			/* @__PURE__ */ jsx(Label, {
+				x: BODY_X,
+				y: .28,
+				text: `B \u00b7 ${scene.nameB} \u00b7 ${massB} kg`,
+				color: BODY,
+				size: 14,
+				weight: 650
+			}),
+			/* @__PURE__ */ jsx(MechanicsVector, {
+				tail: {
+					x: -5.6,
+					y: Y_ACCEL
+				},
+				tip: {
+					x: -5.6 - lenA,
+					y: Y_ACCEL
+				},
+				color: ACCEL,
+				weight: 2.5,
+				label: `a = ${fmtA(accelA)} m/s\u00b2`,
+				labelAt: {
+					x: -5.6 - lenA / 2,
+					y: -.55
+				}
+			}),
+			/* @__PURE__ */ jsx(MechanicsVector, {
+				tail: {
+					x: BODY_X,
+					y: Y_ACCEL
+				},
+				tip: {
+					x: BODY_X + lenB,
+					y: Y_ACCEL
+				},
+				color: ACCEL,
+				weight: 2.5,
+				label: `a = ${fmtA(accelB)} m/s\u00b2`,
+				labelAt: {
+					x: BODY_X + lenB / 2,
+					y: -.55
+				}
+			})
+		]
+	}) });
+	const instruments = /* @__PURE__ */ jsxs(Fragment$1, { children: [
+		/* @__PURE__ */ jsxs("div", {
+			className: "physics-probe",
+			children: [
+				/* @__PURE__ */ jsx("span", { children: "The pair" }),
+				/* @__PURE__ */ jsx("strong", {
+					className: "physics-equation-result",
+					children: /* @__PURE__ */ jsx(Tex$1, { tex: `F_{\\text{A on B}}=F_{\\text{B on A}}=${force}\\,\\mathrm{N}` })
+				}),
+				/* @__PURE__ */ jsx("small", { children: "One interaction, two forces, one applied to each body" })
+			]
+		}),
+		/* @__PURE__ */ jsxs("div", {
+			className: "physics-probe",
+			children: [
+				/* @__PURE__ */ jsx("span", { children: "What each body does" }),
+				/* @__PURE__ */ jsx("strong", {
+					className: "physics-equation-result",
+					children: /* @__PURE__ */ jsx(Tex$1, { tex: `a_A=\\frac{${force}}{${massA}}=${fmtA(accelA)}\\quad a_B=\\frac{${force}}{${massB}}=${fmtA(accelB)}\\ \\mathrm{m/s^2}` })
+				}),
+				/* @__PURE__ */ jsx("small", { children: massA === massB ? "Equal masses, so the two accelerations match as well" : `The ${massA > massB ? "lighter" : "heavier"} body accelerates ${fmtA(Math.max(accelA, accelB) / Math.min(accelA, accelB))} times as fast, from the same force` })
+			]
+		}),
+		/* @__PURE__ */ jsxs("p", {
+			className: "physics-explain",
+			children: [
+				"Horse and cart: the horse pulls the cart forward and the cart pulls the horse back just as hard, yet the cart still moves, because the horse’s pull is the only one of those two forces applied",
+				" ",
+				/* @__PURE__ */ jsx("em", { children: "to the cart" }),
+				"."
+			]
+		})
+	] });
+	const controls = /* @__PURE__ */ jsxs(Fragment$1, { children: [
+		/* @__PURE__ */ jsx(Control, {
+			name: "situation",
+			children: /* @__PURE__ */ jsxs("div", {
+				className: "lab-segmented-field",
+				children: [/* @__PURE__ */ jsx("span", {
+					className: "lab-field-label",
+					children: "situation"
+				}), /* @__PURE__ */ jsx(ActivitySelect, {
+					ariaLabel: "interaction",
+					value: scenario,
+					onChange: setScenario,
+					options: Object.keys(SCENARIOS).map((key) => ({
+						value: key,
+						label: SCENARIOS[key].chip
+					}))
+				})]
+			})
+		}),
+		/* @__PURE__ */ jsx(Field, {
+			label: "push force",
+			value: `${force} N`,
+			children: /* @__PURE__ */ jsx(Slider, {
+				value: force,
+				min: 10,
+				max: F_MAX,
+				step: 10,
+				onChange: setForce,
+				ariaLabel: "size of the interaction force in newtons"
+			})
+		}),
+		/* @__PURE__ */ jsx(Field, {
+			label: "mass A",
+			value: `${massA} kg`,
+			children: /* @__PURE__ */ jsx(Slider, {
+				value: massA,
+				min: 1,
+				max: 120,
+				step: 1,
+				onChange: setMassA,
+				ariaLabel: `mass of body A in kilograms`
+			})
+		}),
+		/* @__PURE__ */ jsx(Field, {
+			label: "mass B",
+			value: `${massB} kg`,
+			children: /* @__PURE__ */ jsx(Slider, {
+				value: massB,
+				min: 1,
+				max: 120,
+				step: 1,
+				onChange: setMassB,
+				ariaLabel: `mass of body B in kilograms`
+			})
+		})
+	] });
+	return /* @__PURE__ */ jsx(AuthoredActivityRuntime, {
+		focusLayout: "immersive",
+		activity: {
+			...authoredActivity,
+			objectives: objectives ?? authoredActivity.objectives
+		},
+		activityId,
+		eyebrow: "Mechanics",
+		title,
+		description: prompt,
+		status: /* @__PURE__ */ jsxs(Fragment$1, { children: [
+			/* @__PURE__ */ jsx("span", { children: scene.status }),
+			/* @__PURE__ */ jsxs("span", { children: [
+				"F ",
+				force,
+				" N"
+			] }),
+			/* @__PURE__ */ jsxs("span", { children: [
+				massA,
+				" : ",
+				massB,
+				" kg"
+			] })
+		] }),
+		evidence: instruments,
+		controls,
+		observation: ({ sequence }) => sequence.current.phase === "explain" ? "Equal and opposite is not the test. Two bodies is the test: weight and the table’s push both act on the book, so they balance it rather than pair with it." : "The two force arrows keep the same length however far apart you drag the masses. They cannot cancel, because each one is the only member of the pair inside its own box.",
+		transcript: /* @__PURE__ */ jsx("p", { children: `${scene.nameA} and ${scene.nameB} interact once. ${scene.nameB} pushes ${scene.nameA} with ${force} newtons, and ${scene.nameA} pushes ${scene.nameB} back with the same ${force} newtons in the opposite direction. Because ${scene.nameA} has a mass of ${massA} kilograms it accelerates at ${fmtA(accelA)} metres per second squared, while ${scene.nameB} at ${massB} kilograms accelerates at ${fmtA(accelB)}.` }),
+		children: ({ complete }) => /* @__PURE__ */ jsxs(Fragment$1, { children: [
+			/* @__PURE__ */ jsx(AuthoredMetricGate, {
+				conditionId: "mass-changed",
+				met: massA !== massAKg || massB !== massBKg,
+				complete
+			}),
+			/* @__PURE__ */ jsx(AuthoredMetricGate, {
+				conditionId: "scenario-changed",
+				met: scenario !== scenario0,
+				complete
+			}),
+			figure
+		] })
+	});
+}
+
+//#endregion
+export { ForcePairsLab };