世界可以写成数学。代码让它运行起来。 The world can be described in mathematics. Code makes that description run.

// radius in tangent units, then as an angle. frameFraction = tan(α/2)/tan(fovY/2), solved for α.
export const MOON_T_R = MOON.frameH * TAN_Y;                 // 0.079192
export const MOON_ANG_R = Math.atan(MOON_T_R);               // 4.528° — half-angle
export const MOON_T_Y = (MOON.centreY - 0.5) * 2 * TAN_Y;    // centre, above the lens axis
// The brief said 8.8°; that is the small-angle read of the same equation (8.8/18 ≈ ½). Solved
// through the tangent it is 9.06°, and the difference is 1.4% of the frame's height. The exact
// one is used, because every other number below divides by it.
export const MOON_MAGNIFICATION = (MOON_ANG_R * 2) / rad(0.53);   // ≈ 17×, vs the real moon

// ---- the points, derived in order ----
export const P = {};
P.rearAxle = [0, WHEEL.R];
P.frontAxle = [GEO.wheelbase, WHEEL.R];
P.bbY = WHEEL.R - GEO.drop;
// rule 1: the BB is where the chainstay reaches
P.bbX = Math.sqrt(GEO.chainstay ** 2 - GEO.drop ** 2);
P.bb = [P.bbX, P.bbY];

// rule 2: walk back up the steering axis from the front axle, then back off the rake
const a = rad(GEO.headAngle);
const axisUp = [-Math.cos(a), Math.sin(a)];                 // up-and-back along the steerer
const rakeDir = [Math.sin(a), Math.cos(a)];                 // perpendicular, pointing forward
P.crown = [
  P.frontAxle[0] + axisUp[0] * GEO.forkLen - rakeDir[0] * GEO.rake,
  P.frontAxle[1] + axisUp[1] * GEO.forkLen - rakeDir[1] * GEO.rake,
];
P.headTop = [P.crown[0] + axisUp[0] * GEO.headTube, P.crown[1] + axisUp[1] * GEO.headTube];
// the head tube does NOT start at the crown: the fork crown, its race and the lower headset cup
// all stack below it. Start the tube on the crown and there is nowhere for the front brake's
// barrel adjuster to be except inside the head tube — which is exactly where its cable vanished.
P.headBottom = [P.crown[0] + axisUp[0] * 0.0290, P.crown[1] + axisUp[1] * 0.0290];

// rule 2 — the finder has to see over the throat
if (PRISM.apexY <= MOUNT.axisY + MOUNT.throatR)
  throw new Error('params: the prism is shorter than the mount throat it has to look over');

// rule 3a — parked, the lever tip must stay inside the body outline
{
  const a = (CONTROLS.windRest * Math.PI) / 180;
  const tipX = CONTROLS.windPivotX + CONTROLS.windLen * Math.cos(a);
  const tipZ = CONTROLS.windPivotZ + CONTROLS.windLen * Math.sin(a);
  if (Math.abs(tipX) > BODY.w / 2 - 0.001 || Math.abs(tipZ) > BODY.d / 2 - 0.001)
    throw new Error(`params: the parked wind lever hangs off the body (${tipX.toFixed(4)}, ${tipZ.toFixed(4)})`);
  // rule 3b — swung out, it must not sweep through the prism
  const b = a + (CONTROLS.windThrow * Math.PI) / 180;
  const endX = CONTROLS.windPivotX + CONTROLS.windLen * Math.cos(b);
  if (endX < PRISM.w0 / 2)
    throw new Error('params: the wind lever ends its throw inside the pentaprism');

// rule 1 — the arm is as long as it has to be, and no longer
ARM.reach = (PROP.R + PROP.clearance / 2) / Math.sin((ARM.spreadDeg * Math.PI) / 180);

export const MOTOR = [];
{
  const a = (ARM.spreadDeg * Math.PI) / 180;
  const sx = Math.sin(a) * ARM.reach, sz = Math.cos(a) * ARM.reach;
  // front-left, front-right, back-right, back-left; handedness alternates (rule 3)
  MOTOR.push({ x: -sx, z: sz, spin: 1 });
  MOTOR.push({ x: sx, z: sz, spin: -1 });
  MOTOR.push({ x: sx, z: -sz, spin: 1 });
  MOTOR.push({ x: -sx, z: -sz, spin: -1 });

/** The one point on the platen surface that the ribbon, the bar tips and the sheet all meet. */
export const TYPE_POINT = {
  y: PLATEN.y + CARRIAGE.platenR * Math.cos(rad(TYPEBARS.typeAngle)),
  z: PLATEN.z + CARRIAGE.platenR * Math.sin(rad(TYPEBARS.typeAngle)),
};

/** Bar length is the reach from the segment fulcrum to the type point — derived, never typed.
 *  A bar rotated to 0° puts its head exactly on the platen surface; `rest` swings it back. */
export const BAR_LEN = Math.hypot(
  TYPE_POINT.y - TYPEBARS.fulcrumY,
  TYPE_POINT.z - TYPEBARS.fulcrumZ,
);

/** Angle the raised bar makes with vertical, so the head can be squared up to the platen. */
export const BAR_LEAN = Math.atan2(
  TYPE_POINT.z - TYPEBARS.fulcrumZ,

/** Rule 1: the string length, and where it puts everything. */
export const SCALE = {
  vibrating: 0.3250,        // = neckStop + bodyStop, and the two are in the maker's 2:3
  neckStop: 0.1300,          // nut → the body's edge at the neck
  bodyStop: 0.1950,          // that edge → the bridge
  fingerboard: 0.2700,
  fbWidthNut: 0.0240, fbWidthEnd: 0.0420,
  fbThick: 0.0060,
};
if (Math.abs(SCALE.neckStop + SCALE.bodyStop - SCALE.vibrating) > 1e-9)
  throw new Error('params: the neck stop and the body stop do not add up to the string length');

export function halfBeam(z) {
  const t = (z - HULL.zMaxBeam) / (HULL.lod / 2);
  if (t >= 0) {
    // Forward of max beam. Two terms, and the second one is the whole argument:
    //   · a cubic that leaves max beam flat and arrives at the stem with a FINITE slope — that
    //     slope is the half-angle of entrance, 14°, and it is what "sharp bow" actually means;
    //   · a bump SUBTRACTED over the forward third. A subtracted bump makes the curve convex
    //     there, and a convex plan curve lies inside its own chord — which is the definition of
    //     a hollow waterline. Fineness alone is not hollow: the first cut of this hull was fine
    //     everywhere and curved the same way from end to end, and read as a leaf.
    const u = Math.min(1, t / (1 - HULL.zMaxBeam / (HULL.lod / 2)));
    const cubic = 1 - 1.5 * u ** 2 + 0.5 * u ** 3;
    const s = Math.max(0, (u - 0.55) / 0.45);
    const hollow = 0.090 * Math.sin(Math.PI * Math.min(1, s)) ** 2;
    return (HULL.beam / 2) * Math.max(0, cubic - hollow);