<!-- SOLID CITY · part 2505 -->
ht
    var pkX = rec.x + rx * (rec.padW / 2 + 3.6) + fx * (frontL - 3), pkZ = rec.z + rz * (rec.padW / 2 + 3.6) + fz * (frontL - 3);
    var pkY = groundAt(pkX, pkZ);
    BASE = M4(pkX, pkY + 0.06, pkZ, rec.ry, 0, 0);
    box(solid, 5.6, 0.16, 5.6, 0, 0, 0, C.path);
    standQuad(pkX, pkY + 0.06, pkZ, rec.ry, 0, 5.6, 5.6, 0.08);
    BASE = new T.Matrix4();
    if (R() < 0.55) { BASE = M4(pkX, pkY + 0.14, pkZ, rec.ry + (R() - 0.5) * 0.2, 0, 0); car(CAR_COLS[Math.floor(R() * CAR_COLS.length)]); BASE = new T.Matrix4(); }
    // driveway: parking pad -> nearest road (shared/short spurs are fine)
    if (!ROADS_REJECTED && roadPt.dist < 85) {   // THE REJECTION: pads and paths remain; no drive runs to a road that never rose
      // THE DRIVEWAY GRADE LAW: the nearest point of road is not
      // always a lawful target — a pad 3.4 m below a road's edge
      // and 3 m from it can only be reached by a paved wall.
      // Choose, among every station within reach, the gentlest
      // climb: rise over run, the pad's height against the
      // station's. The drive still ends at the road's own
      // surface (endY), on whichever road asks the least of it.
      var tgt = null, tScore = 1e12;
      /* THE PROPER DRIVEWAY (the King's word, 2026-10-14
       * ~01:34): "give every house the proper driveway they
       * deserve." The reach was 40 m, and the census it starved
       * was plain: nine pads stood 48 to 79 m from their nearest
       * station — within sight of the road, beyond the law's
       * reach, with no driveway at all. The reach is now 100 m.
       * The gentlest-station law is unchanged: a longer run
       * that climbs gentler beats a short wall, at household
       * scale as on the mountain — use what we can, build over
       * what is there, add what we need. */
      for (var rn2 in smithRoads) { var ests = smithRoads[rn2].stations; for (var eq = 0; eq < ests.length; eq++) { var es = ests[eq], edx = es.x - pkX, edz = es.z - pkZ, edist = Math.sqrt(edx * edx + edz * edz); if (edist > 100) continue; var esc = Math.abs(es.y - (pkY + 0.06)) / Math.max(edist, 2.5); if (esc < tScore) { tScore = esc; tgt = es; } } }
      if (tgt) {
        /* THE DRIVEWAY'S OWN SWITCHBACK: one house — the highest
         * of the High Benches — stands some 50 m above every
         * station in reach; even the gentlest straight drive is
         * a 50% pitch, a staircase wearing a driveway's name.
         * So where the best straight climb still exceeds 30%,
         * the drive bends once, traversing like the mountain
         * roads themselves: two legs through a bend point set
         * sideways by the length the climb needs, each leg at
         * 30% or gentler. The bend stands on whichever side's
         * ground lies closer to the drive's own height there. */
        var ddx = tgt.x - pkX, ddz = tgt.z - pkZ, dLen = Math.hypot(ddx, ddz) || 1;
        if (tScore > 0.30) {
          var need = Math.abs(tgt.y - (pkY + 0.06)) / 0.30, half = need / 2;
          var off = Math.sqrt(Math.max(half * half - (dLen / 2) * (dLen / 2), 0));
          if (off > 4 && off < 90) {
            var mxp = (pkX + tgt.x) / 2, mzp = (pkZ + tgt.z) / 2, midY = (pkY + 0.06 + tgt.y) / 2;
            var pxu = -ddz / dLen, pzu = ddx / dLen;
            var bA = [mxp + pxu * off, mzp + pzu * off], bB = [mxp - pxu * off, mzp - pzu * off];
            var bend = Math.abs(groundAt(bA[0], bA[1]) - midY) <= Math.abs(groundAt(bB[0], bB[1]) - midY) ? bA : bB;
            steppedPath(pkX, pkZ, bend[0], bend[1], 3.4, C.drive, 3.6);
            steppedPath(bend[0], bend[1], tgt.x, tgt.z, 3.4, C.drive, 3.6, tgt.y);
            driveMouths.push([tgt.x, tgt.z]);
          } else { steppedPath(pkX, pkZ, tgt.x, tgt.z, 3.4, C.drive, 3.6, tgt.y); driveMouths.push([tgt.x, tgt.z]); }
        } else { steppedPath(pkX, pkZ, tgt.x, tgt.z, 3.4, C.drive, 3.6, tgt.y); driveMouths.push([tgt.x, tgt.z]); }
      }
    }
    // walking path: parking pad -> front steps, lined with small yellow stones (the King's photos)
    steppedPath(pkX, pkZ, doorX, doorZ, 1.7, C.path, 2.6);
    var plen = Math.hypot(doorX - pkX, doorZ - pkZ), pn = Math.max(2, Math.floor(plen / 2.2));
    for (var i = 0; i <= pn; i++) {
      var t = i / pn, sx2 = pkX + (doorX - pkX) * t, sz2 = pkZ + (doorZ - pkZ) * t;
      var ox = -(doorZ - pkZ) / (plen || 1) * 1.25, oz = (doorX - pkX) / (plen || 1) * 1.25;
      BASE = M4(sx2 + ox, groundAt(sx2 + ox, sz2 + oz) + 0.02, sz2 + oz, 0, 0, 0);
      rock(solid, 0.3, 0, 0.1, 0, C.yellowStone);
      BASE = new T.Matrix4();
    }
    // a mailbox where the path meets the drive
    BASE = M4(pkX - rx * 2.2, groundAt(pkX - rx * 2.2, pkZ - rz * 2.2), pkZ - rz * 2.2, rec.ry, 0, 0);
    box(solid, 0.14, 1.05, 0.14, 0, 0.52, 0, C.woodDark);
    box(solid, 0.75, 0.4, 0.45, 0, 1.2, 0, R() < 0.5 ? 0x8a3030 : C.stoneDark);
    BASE = new T.Matrix4();
    rec.door = [doorX, doorZ]; rec.park = [pkX, pkZ];
  }
  /* T